Jak ustawić nagłówek Content-Type dla żądania HttpClient?

Próbuję ustawić Content-Typenagłówek HttpClientobiektu zgodnie z wymaganiami wywoływanego interfejsu API.

Próbowałem ustawić Content-Typeponiżej:

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

Pozwala mi to dodać Acceptnagłówek, ale gdy próbuję go dodać Content-Type, zgłasza następujący wyjątek:

Niewłaściwie użyta nazwa nagłówka. Upewnij się, że używane są nagłówki żądania, nagłówki HttpRequestMessageodpowiedzi z HttpResponseMessageoraz nagłówki zawartości z HttpContentobiektami.

Jak ustawić Content-Typenagłówek w HttpClientżądaniu?

Typ zawartości jest nagłówkiem treści, a nie żądania, dlatego to się nie udaje. AddWithoutValidationzgodnie z sugestią Roberta Levy'ego może działać, ale można również ustawić typ zawartości podczas tworzenia treści żądania (pamiętaj, że fragment kodu dodaje „application / json” w dwóch miejscach - dla nagłówków Accept i 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);
      });

Dla tych, którzy nie widzieli Johnsa komentarza do rozwiązania Carlos ...

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

Jeśli nie przeszkadza ci mała zależność od biblioteki, Flurl.Http [ujawnienie: jestem autorem] sprawia, że ​​jest to bardzo proste. Ta PostJsonAsyncmetoda zajmuje się serializowaniem treści i ustawieniem content-typenagłówka oraz ReceiveJsondeserializacją odpowiedzi. Jeśli acceptnagłówek jest wymagany, musisz ustawić go sam, ale Flurl zapewnia całkiem czysty sposób na zrobienie tego:

using Flurl.Http;

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

Flurl używa HttpClient i Json.NET pod maską, i jest to PCL, więc będzie działał na różnych platformach.

PM> Install-Package Flurl.Http

spróbuj użyć TryAddWithoutValidation

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

.Net próbuje zmusić cię do przestrzegania pewnych standardów, a mianowicie, że Content-Typenagłówek może być określony tylko na wnioski, które mają zawartość (np POST, PUTitp). Dlatego, jak wskazali inni, preferowanym sposobem ustawienia Content-Typenagłówka jest HttpContent.Headers.ContentTypewłaściwość.

Mając to na uwadze , niektóre interfejsy API (takie jak LiquidFiles Api , od 19.12.2016) wymagają ustawienia Content-Typenagłówka GETżądania. .Net nie zezwoli na ustawienie tego nagłówka na samym żądaniu - nawet przy użyciu TryAddWithoutValidation. Ponadto nie można określić Contentżądania dla - nawet jeśli ma ono zerową długość. Jedynym sposobem, w jaki mogłem to obejść, było uciekanie się do refleksji. Kod (na wypadek, gdyby ktoś go potrzebował) to

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

Edytować:

Jak zauważono w komentarzach, pole to ma różne nazwy w różnych wersjach biblioteki dll. W kodzie źródłowym na GitHub pole ma obecnie nazwę s_invalidHeaders. Przykład został zmodyfikowany, aby uwzględnić to zgodnie z sugestią @David Thompson.

Niektóre dodatkowe informacje o .NET Core (po przeczytaniu postu erdomke o ustawianiu prywatnego pola do dostarczenia typu zawartości na żądanie, które nie zawiera treści) ...

Po debugowaniu mojego kodu nie widzę pola prywatnego, które można ustawić poprzez odbicie - pomyślałem więc, że spróbuję odtworzyć problem.

Próbowałem następujący kod przy użyciu .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;

I zgodnie z oczekiwaniami otrzymuję zbiorczy wyjątek z treścią "Cannot send a content-body with this verb-type."

Jeśli jednak zrobię to samo z .NET Core (1.1) - nie otrzymam wyjątku.Moja aplikacja na serwer dość szczęśliwie odpowiedziała i pobrano typ zawartości.

Byłem mile zaskoczony tym i mam nadzieję, że to komuś pomoże!

Zadzwoń AddWithoutValidationzamiast Add(patrz ten link MSDN ).

Alternatywnie, zgaduję, że interfejs API, którego używasz, naprawdę wymaga tylko tego dla żądań POST lub PUT (nie zwykłe żądania GET). W takim przypadku, gdy wywołujesz HttpClient.PostAsynci przekazujesz HttpContent, ustaw to na Headerswłaściwość tego HttpContentobiektu.

Dla tych, którzy się martwili charset

Miałem bardzo szczególny przypadek, że dostawca usług nie zaakceptował zestawu znaków, a oni odmówili zmiany podstruktury, aby na to pozwolić ... Niestety HttpClient ustawiał nagłówek automatycznie za pośrednictwem StringContent i bez względu na to, czy podasz null lub Encoding.UTF8, zawsze ustawi zestaw znaków ...

Dzisiaj byłem na krawędzi, aby zmienić podsystem; przechodząc od HttpClient do czegokolwiek innego, że coś przyszło mi do głowy ... dlaczego nie użyć refleksji, aby opróżnić „zestaw znaków”? ... I zanim jeszcze spróbowałem, pomyślałem o pewnym „może mogę to zmienić po inicjalizacji” i to zadziałało.

Oto jak ustawić dokładny nagłówek „application / json” bez „; 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;

Uwaga: Poniższa nullwartość nie będzie działać i dopisuje „; charset = utf-8”

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

EDYTOWAĆ

@DesertFoxAZ sugeruje, że można również użyć następującego kodu i działa dobrze. (sam tego nie testowałem)

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

To wszystko, czego potrzebujesz.

Korzystając z Newtonsoft.Json, jeśli potrzebujesz zawartości jako ciągu 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, to nie jest HTTPClient, ale jeśli możesz go użyć, WebClient jest dość łatwy:

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

Możesz tego użyć, to będzie praca!

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

Uważam to za najprostsze i najłatwiejsze do zrozumienia w następujący sposób:

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

Musisz to zrobić w następujący sposób:

    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;