Comment définissez-vous l'en-tête Content-Type pour une demande HttpClient?

J'essaie de définir l'en- Content-Typetête d'un HttpClientobjet comme requis par une API que j'appelle.

J'ai essayé de définir Content-Typecomme ci-dessous:

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");
    // ...
}

Cela me permet d'ajouter l'en- Accepttête mais lorsque j'essaye de l'ajouter, Content-Typeil lance l'exception suivante:

Nom d'en-tête mal utilisé. Assurez-vous que les en-têtes de demande sont utilisés avec HttpRequestMessage, les en-têtes de réponse avec HttpResponseMessageet les en-têtes de contenu avec les HttpContentobjets.

Comment puis-je définir l'en- Content-Typetête dans une HttpClientdemande?

Le type de contenu est un en-tête du contenu, pas de la demande, c'est pourquoi cela échoue. AddWithoutValidationcomme suggéré par Robert Levy peut fonctionner, mais vous pouvez également définir le type de contenu lors de la création du contenu de la demande lui-même (notez que l'extrait de code ajoute "application / json" à deux endroits - pour les en-têtes Accept et 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);
      });

Pour ceux qui n'ont pas vu le commentaire de Johns sur la solution carlos ...

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

Si cela ne vous dérange pas une petite dépendance de bibliothèque, Flurl.Http [divulgation: je suis l'auteur] rend cela ultra simple. Sa PostJsonAsyncméthode prend en charge à la fois la sérialisation du contenu et la définition de l'en- content-typetête, et ReceiveJsondésérialise la réponse. Si l'en- accepttête est requis, vous devrez le définir vous-même, mais Flurl fournit également un moyen assez propre de le faire:

using Flurl.Http;

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

Flurl utilise HttpClient et Json.NET sous le capot, et c'est un PCL, donc cela fonctionnera sur une variété de plates-formes.

PM> Install-Package Flurl.Http

essayez d'utiliser TryAddWithoutValidation

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

.Net essaie de vous forcer à obéir à certaines normes, à savoir que l' en- Content-Typetête ne peut être spécifié sur les demandes qui ont un contenu (par exemple POST, PUTetc.). Par conséquent, comme d'autres l'ont indiqué, la meilleure façon de définir l'en- Content-Typetête consiste à utiliser la HttpContent.Headers.ContentTypepropriété.

Cela dit, certaines API (telles que l' API LiquidFiles , à partir du 2016-12-19) nécessitent de définir l'en- Content-Typetête d'une GETdemande. .Net ne permettra pas de définir cet en-tête sur la demande elle-même - même en utilisant TryAddWithoutValidation. De plus, vous ne pouvez pas spécifier un Contentpour la demande - même s'il est de longueur nulle. La seule façon dont je pouvais sembler contourner cela était de recourir à la réflexion. Le code (au cas où quelqu'un d'autre en aurait besoin) est

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");

Éditer:

Comme indiqué dans les commentaires, ce champ a des noms différents dans différentes versions de la DLL. Dans le code source sur GitHub , le champ est actuellement nommé s_invalidHeaders. L'exemple a été modifié pour tenir compte de cela selon la suggestion de @David Thompson.

Quelques informations supplémentaires sur .NET Core (après avoir lu le post d'erdomke sur la définition d'un champ privé pour fournir le type de contenu sur une demande qui n'a pas de contenu) ...

Après avoir débogué mon code, je ne vois pas le champ privé à définir via la réflexion - j'ai donc pensé essayer de recréer le problème.

J'ai essayé le code suivant en utilisant .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;

Et, comme prévu, j'obtiens une exception globale avec le contenu "Cannot send a content-body with this verb-type."

Cependant, si je fais la même chose avec .NET Core (1.1) - je n'ai pas d'exception.Ma demande a été très heureusement répondu par mon application serveur, et le type de contenu a été repris.

J'en ai été agréablement surpris et j'espère que cela aide quelqu'un!

Appelez AddWithoutValidationau lieu de Add(voir ce lien MSDN ).

Alternativement, je suppose que l'API que vous utilisez ne l'exige vraiment que pour les requêtes POST ou PUT (pas les requêtes GET ordinaires). Dans ce cas, lorsque vous appelez HttpClient.PostAsyncet transmettez un HttpContent, définissez-le sur la Headerspropriété de cet HttpContentobjet.

Pour ceux qui ont des problèmes avec charset

J'ai eu un cas très spécial que le fournisseur de services n'a pas accepté charset, et ils refusent de changer la sous-structure pour le permettre ... Malheureusement, HttpClient définissait automatiquement l'en-tête via StringContent, et peu importe si vous passez null ou Encoding.UTF8, il définira toujours le jeu de caractères ...

Aujourd'hui, j'étais sur le point de changer le sous-système; passer de HttpClient à autre chose, que quelque chose m'est venu à l'esprit ..., pourquoi ne pas utiliser la réflexion pour vider le "charset"? ... Et avant même de l'essayer, j'ai pensé à un moyen, "peut-être que je peux le changer après l'initialisation", et cela a fonctionné.

Voici comment définir l'en-tête "application / json" exact sans "; 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;

Remarque: La nullvaleur de ce qui suit ne fonctionnera pas et ajoutera "; charset = utf-8"

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

ÉDITER

@DesertFoxAZ suggère que le code suivant peut également être utilisé et fonctionne correctement. (je ne l'ai pas testé moi-même)

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"));

C'est tout ce dont vous avez besoin.

En utilisant Newtonsoft.Json, si vous avez besoin d'un contenu en tant que chaîne json.

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, ce n'est pas HTTPClient mais si vous pouvez l'utiliser, WebClient est assez simple:

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(...);
 }

Vous pouvez l'utiliser, ce sera du travail!

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();

Je le trouve le plus simple et le plus facile à comprendre de la manière suivante:

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();

Vous devez le faire comme ceci:

    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;