Como você define o cabeçalho Content-Type para uma solicitação HttpClient?

Estou tentando definir o Content-Typecabeçalho de um HttpClientobjeto, conforme exigido por uma API que estou chamando.

Tentei definir o Content-Typeseguinte abaixo:

using (var httpClient = new HttpClient())
{
    httpClient.BaseAddress = new Uri("http://example.com/");
    httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
    httpClient.DefaultRequestHeaders.Add("Content-Type", "application/json");
    // ...
}

Ele permite que eu adicione o Acceptcabeçalho, mas quando tento adicioná- Content-Typelo lança a seguinte exceção:

Nome de cabeçalho mal utilizado. Verifique se os cabeçalhos de solicitação são usados ​​com HttpRequestMessage, de resposta HttpResponseMessagee de conteúdo com HttpContentobjetos.

Como posso definir o Content-Typecabeçalho em uma HttpClientsolicitação?

O tipo de conteúdo é um cabeçalho do conteúdo, não da solicitação, e é por isso que está falhando. AddWithoutValidationconforme sugerido por Robert Levy pode funcionar, mas você também pode definir o tipo de conteúdo ao criar o próprio conteúdo da solicitação (observe que o snippet de código adiciona "application / json" em dois locais - para os cabeçalhos Accept e Content-Type):

HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://example.com/");
client.DefaultRequestHeaders
      .Accept
      .Add(new MediaTypeWithQualityHeaderValue("application/json"));//ACCEPT header

HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "relativeAddress");
request.Content = new StringContent("{\"name\":\"John Doe\",\"age\":33}",
                                    Encoding.UTF8, 
                                    "application/json");//CONTENT-TYPE header

client.SendAsync(request)
      .ContinueWith(responseTask =>
      {
          Console.WriteLine("Response: {0}", responseTask.Result);
      });

Para quem não viu o Johns comentar a solução carlos ...

req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");

Se você não se importa com uma pequena dependência de biblioteca, o Flurl.Http [divulgação: eu sou o autor] torna isso extremamente simples. Seu PostJsonAsyncmétodo cuida da serialização do conteúdo e da configuração do content-typecabeçalho e ReceiveJsondesserializa a resposta. Se o acceptcabeçalho for necessário, você precisará definir isso sozinho, mas o Flurl também oferece uma maneira bastante limpa de fazer isso:

using Flurl.Http;

var result = await "http://example.com/"
    .WithHeader("Accept", "application/json")
    .PostJsonAsync(new { ... })
    .ReceiveJson<TResult>();

O Flurl usa o HttpClient e o Json.NET sob o capô, e é um PCL para funcionar em várias plataformas.

PM> Install-Package Flurl.Http

tente usar TryAddWithoutValidation

  var client = new HttpClient();
  client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json; charset=utf-8");

.Net tenta forçá-lo a obedecer a certas normas, ou seja, que o Content-Typecabeçalho só pode ser especificada em pedidos que tenham conteúdo (por exemplo POST, PUT, etc.). Portanto, como outros indicaram, a maneira preferida de definir o Content-Typecabeçalho é através da HttpContent.Headers.ContentTypepropriedade

Com isso dito, determinadas APIs (como a LiquidFiles Api , em 19/12/2016) exigem a configuração do Content-Typecabeçalho para uma GETsolicitação. .Net não permitirá definir esse cabeçalho na própria solicitação - mesmo usando TryAddWithoutValidation. Além disso, você não pode especificar a Contentpara a solicitação - mesmo que seja de comprimento zero. A única maneira que eu conseguia contornar isso era recorrer à reflexão. O código (no caso de alguém precisar dele) é

var field = typeof(System.Net.Http.Headers.HttpRequestHeaders)
    .GetField("invalidHeaders", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static) 
  ?? typeof(System.Net.Http.Headers.HttpRequestHeaders) 
    .GetField("s_invalidHeaders", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
if (field != null)
{
  var invalidFields = (HashSet<string>)field.GetValue(null);
  invalidFields.Remove("Content-Type");
}
_client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "text/xml");

Editar:

Conforme observado nos comentários, esse campo tem nomes diferentes em diferentes versões da DLL. No código fonte do GitHub , o campo está atualmente nomeado s_invalidHeaders. O exemplo foi modificado para explicar isso de acordo com a sugestão de @David Thompson.

Algumas informações adicionais sobre o .NET Core (depois de ler a postagem de erdomke sobre como definir um campo privado para fornecer o tipo de conteúdo em uma solicitação que não possui conteúdo) ...

Depois de depurar meu código, não consigo ver o campo privado para definir via reflexão - então pensei em tentar recriar o problema.

Eu tentei o seguinte código usando o .Net 4.6:

HttpRequestMessage httpRequest = new HttpRequestMessage(HttpMethod.Get, @"myUrl");
httpRequest.Content = new StringContent(string.Empty, Encoding.UTF8, "application/json");

HttpClient client = new HttpClient();
Task<HttpResponseMessage> response =  client.SendAsync(httpRequest);  //I know I should have used async/await here!
var result = response.Result;

E, como esperado, recebo uma exceção agregada com o conteúdo "Cannot send a content-body with this verb-type."

No entanto, se eu fizer a mesma coisa com o .NET Core (1.1) - não recebo uma exceção. Minha solicitação foi atendida com satisfação pelo meu aplicativo de servidor e o tipo de conteúdo foi escolhido.

Fiquei agradavelmente surpreso com isso, e espero que ajude alguém!

Ligue em AddWithoutValidationvez deAdd (consulte este link do MSDN ).

Como alternativa, acho que a API que você está usando realmente exige isso apenas para solicitações POST ou PUT (não solicitações GET comuns). Nesse caso, quando você chamar HttpClient.PostAsynce passar um HttpContent, defina isso na Headerspropriedade desse HttpContentobjeto.

Para aqueles que se preocuparam com charset

Eu tive um caso muito especial de que o provedor de serviços não aceitava charset e eles se recusam a alterar a subestrutura para permitir isso ... Infelizmente, o HttpClient estava configurando o cabeçalho automaticamente por meio de StringContent, e não importa se você passa nulo ou Encoding.UTF8, sempre definirá o conjunto de caracteres ...

Hoje eu estava no limite para mudar o subsistema; passando de HttpClient para qualquer outra coisa, que algo veio à minha mente ..., por que não usar a reflexão para esvaziar o "conjunto de caracteres"? ... E antes mesmo de tentar, pensei em uma maneira "talvez eu possa alterá-lo após a inicialização", e funcionou.

Veja como você pode definir o cabeçalho "application / json" exato sem "; charset = utf-8".

var jsonRequest = JsonSerializeObject(req, options); // Custom function that parse object to string
var stringContent = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
stringContent.Headers.ContentType.CharSet = null;
return stringContent;

Nota: O nullvalor a seguir não funcionará e acrescente "; charset = utf-8"

return new StringContent(jsonRequest, null, "application/json");

EDITAR

O @DesertFoxAZ sugere que também o código a seguir pode ser usado e funciona bem. (eu mesmo não testei)

stringContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");

var content = new JsonContent();
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
content.Headers.ContentType.Parameters.Add(new NameValueHeaderValue("charset", "utf-8"));
content.Headers.ContentType.Parameters.Add(new NameValueHeaderValue("IEEE754Compatible", "true"));

É tudo o que você precisa.

Com o uso do Newtonsoft.Json, se você precisar de um conteúdo como json string.

public class JsonContent : HttpContent
   {
    private readonly MemoryStream _stream = new MemoryStream();
    ~JsonContent()
    {
        _stream.Dispose();
    }

    public JsonContent(object value)
    {
        Headers.ContentType = new MediaTypeHeaderValue("application/json");
        using (var contexStream = new MemoryStream())
        using (var jw = new JsonTextWriter(new StreamWriter(contexStream)) { Formatting = Formatting.Indented })
        {
            var serializer = new JsonSerializer();
            serializer.Serialize(jw, value);
            jw.Flush();
            contexStream.Position = 0;
            contexStream.WriteTo(_stream);
        }
        _stream.Position = 0;

    }

    private JsonContent(string content)
    {
        Headers.ContentType = new MediaTypeHeaderValue("application/json");
        using (var contexStream = new MemoryStream())
        using (var sw = new StreamWriter(contexStream))
        {
            sw.Write(content);
            sw.Flush();
            contexStream.Position = 0;
            contexStream.WriteTo(_stream);
        }
        _stream.Position = 0;
    }

    protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
    {
        return _stream.CopyToAsync(stream);
    }

    protected override bool TryComputeLength(out long length)
    {
        length = _stream.Length;
        return true;
    }

    public static HttpContent FromFile(string filepath)
    {
        var content = File.ReadAllText(filepath);
        return new JsonContent(content);
    }
    public string ToJsonString()
    {
        return Encoding.ASCII.GetString(_stream.GetBuffer(), 0, _stream.GetBuffer().Length).Trim();
    }
}

Ok, não é HTTPClient, mas se você pode usá-lo, o WebClient é bastante fácil:

using (var client = new System.Net.WebClient())
 {
    client.Headers.Add("Accept", "application/json");
    client.Headers.Add("Content-Type", "application/json; charset=utf-8");
    client.DownloadString(...);
 }

Você pode usar isso, será trabalho!

HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Get,"URL");
msg.Content = new StringContent(string.Empty, Encoding.UTF8, "application/json");

HttpResponseMessage response = await _httpClient.SendAsync(msg);
response.EnsureSuccessStatusCode();

string json = await response.Content.ReadAsStringAsync();

Acho mais simples e fácil de entender da seguinte maneira:

async Task SendPostRequest()
{
    HttpClient client = new HttpClient();
    var requestContent = new StringContent(<content>);
    requestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
    var response = await client.PostAsync(<url>, requestContent);
    var responseString = await response.Content.ReadAsStringAsync();
}
...

SendPostRequest().Wait();

Você precisa fazer assim:

    HttpContent httpContent = new StringContent(@"{ the json string }");
    httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));                
    HttpResponseMessage message = client.PostAsync(@"{url}", httpContent).Result;