Wie legen Sie den Content-Type-Header für eine HttpClient-Anforderung fest?

Ich versuche, den Content-TypeHeader eines HttpClientObjekts so festzulegen, wie es für eine von mir aufgerufene API erforderlich ist.

Ich habe versucht, Content-TypeFolgendes einzustellen:

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

Ich kann den AcceptHeader hinzufügen, aber wenn ich versuche, ihn hinzuzufügen Content-Type, wird die folgende Ausnahme ausgelöst:

Missbrauchter Headername. Stellen Sie sicher, dass Anforderungsheader mit HttpRequestMessage, Antwortheader mit HttpResponseMessageund Inhaltsheader mit HttpContentObjekten verwendet werden.

Wie kann ich den Content-TypeHeader in einer HttpClientAnfrage setzen?

Der Inhaltstyp ist eine Kopfzeile des Inhalts und nicht der Anforderung, weshalb dies fehlschlägt. AddWithoutValidationWie von Robert Levy vorgeschlagen, funktioniert dies möglicherweise, aber Sie können den Inhaltstyp auch festlegen, wenn Sie den Anforderungsinhalt selbst erstellen (beachten Sie, dass das Code-Snippet an zwei Stellen "application / json" hinzufügt - für Header "Akzeptieren" und "Inhaltstyp"):

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

Für diejenigen, die Johns Kommentar zur Carlos-Lösung nicht gesehen haben ...

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

Wenn Ihnen eine kleine Bibliotheksabhängigkeit nichts ausmacht, macht Flurl.Http [Offenlegung: Ich bin der Autor] dies sehr einfach. Die PostJsonAsyncMethode kümmert sich sowohl um die Serialisierung des Inhalts als auch um das Festlegen des content-typeHeaders und ReceiveJsondeserialisiert die Antwort. Wenn der acceptHeader benötigt wird, müssen Sie dies selbst festlegen, aber Flurl bietet auch eine ziemlich saubere Möglichkeit, dies zu tun:

using Flurl.Http;

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

Flurl verwendet HttpClient und Json.NET unter der Haube und ist eine PCL, sodass es auf einer Vielzahl von Plattformen funktioniert.

PM> Install-Package Flurl.Http

Versuchen Sie, TryAddWithoutValidation zu verwenden

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

.Net versucht , Sie zu zwingen , bestimmte Standards zu folgen, nämlich , dass der Content-TypeHeader kann nur auf Anfragen angegeben werden, den Inhalt (zB POST, PUTusw.). Daher ist, wie andere angegeben haben, die bevorzugte Methode zum Festlegen des Content-TypeHeaders die HttpContent.Headers.ContentTypeEigenschaft.

Für bestimmte APIs (z. B. die LiquidFiles- API vom 19.12.2016) muss der Content-TypeHeader für eine GETAnforderung festgelegt werden. .Net erlaubt es nicht, diesen Header für die Anfrage selbst zu setzen - auch nicht mit TryAddWithoutValidation. Darüber hinaus können Sie Contentfür die Anforderung kein a angeben, auch wenn diese keine Länge hat. Die einzige Möglichkeit, dies zu umgehen, bestand darin, auf Reflexion zurückzugreifen. Der Code (falls es jemand anderes braucht) ist

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

Bearbeiten:

Wie in den Kommentaren erwähnt, hat dieses Feld in verschiedenen Versionen der DLL unterschiedliche Namen. Im Quellcode von GitHub wird das Feld derzeit benannt s_invalidHeaders. Das Beispiel wurde geändert, um dies gemäß dem Vorschlag von @David Thompson zu berücksichtigen.

Einige zusätzliche Informationen zu .NET Core (nachdem Sie den Beitrag von erdomke zum Festlegen eines privaten Felds gelesen haben, um den Inhaltstyp für eine Anforderung ohne Inhalt anzugeben) ...

Nach dem Debuggen meines Codes kann ich das private Feld, das durch Reflektion festgelegt werden soll, nicht sehen. Daher dachte ich, ich würde versuchen, das Problem neu zu erstellen.

Ich habe den folgenden Code mit .Net 4.6 ausprobiert:

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;

Und wie erwartet bekomme ich eine aggregierte Ausnahme mit dem Inhalt "Cannot send a content-body with this verb-type."

Wenn ich jedoch dasselbe mit .NET Core (1.1) mache - mache, bekomme ich keine Ausnahme. Meine Anfrage wurde von meiner Serveranwendung sehr gerne beantwortet und der Inhaltstyp wurde aufgegriffen.

Ich war angenehm überrascht und hoffe, dass es jemandem hilft!

Anruf AddWithoutValidationstatt Add(siehe diesen MSDN-Link ).

Alternativ denke ich, dass die API, die Sie verwenden, dies wirklich nur für POST- oder PUT-Anforderungen erfordert (keine gewöhnlichen GET-Anforderungen). Wenn Sie in diesem Fall ein aufrufen HttpClient.PostAsyncund übergeben HttpContent, legen Sie dies für die HeadersEigenschaft dieses HttpContentObjekts fest.

Für diejenigen, die sich Sorgen machen charset

Ich hatte einen ganz besonderen Fall, dass der Dienstanbieter keinen Zeichensatz akzeptierte und sich weigerte, die Unterstruktur zu ändern, um dies zuzulassen ... Leider setzte HttpClient den Header automatisch über StringContent, und egal, ob Sie null oder Encoding.UTF8 übergeben, es wird immer der Zeichensatz eingestellt ...

Heute war ich am Rande, das Subsystem zu ändern; Als ich von HttpClient zu etwas anderem überging, kam mir etwas in den Sinn ..., warum nicht die Reflexion verwenden, um den "Zeichensatz" zu leeren? ... Und bevor ich es überhaupt probiere, habe ich mir überlegt, "vielleicht kann ich es nach der Initialisierung ändern", und das hat funktioniert.

So können Sie den genauen Header "application / json" ohne "; charset = utf-8" setzen.

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;

Hinweis: Der nullfolgende Wert funktioniert nicht und hängt "; charset = utf-8" an.

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

BEARBEITEN

@DesertFoxAZ schlägt vor, dass auch der folgende Code verwendet werden kann und gut funktioniert. (habe es nicht selbst getestet)

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

Es ist alles was Sie brauchen.

Wenn Sie Newtonsoft.Json verwenden, benötigen Sie einen Inhalt als JSON-Zeichenfolge.

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, es ist kein HTTPClient, aber wenn Sie es verwenden können, ist WebClient ganz einfach:

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

Sie können dies verwenden, es wird Arbeit sein!

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

Ich finde es am einfachsten und am leichtesten zu verstehen:

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

Sie müssen es so machen:

    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;