我试图设置一个HttpClient对象的Content-Type头作为我调用的API所要求的。
我试着像下面这样设置内容类型:
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");
// ...
}
它允许我添加Accept头，但当我尝试添加Content-Type时，它会抛出以下异常:
误用头名称。确保请求头与一起使用 HttpRequestMessage，带有HttpResponseMessage的响应头，以及 内容头与HttpContent对象。
如何在HttpClient请求中设置内容类型报头?
调用AddWithoutValidation而不是Add(参见MSDN链接)。
或者，我猜您正在使用的API实际上只需要POST或PUT请求(而不是普通的GET请求)。在这种情况下，当您调用HttpClient时。然后传入一个HttpContent，在HttpContent对象的Headers属性上设置这个。
内容类型是内容的头，而不是请求的头，这就是失败的原因。Robert Levy建议的AddWithoutValidation可以工作，但是你也可以在创建请求内容本身时设置内容类型(注意，代码片段在两个地方添加了application/json - Accept和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);
});
对于那些没有看到约翰对卡洛斯解决方案的评论…
req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
如果你不介意一个小的库依赖，Flurl。Http[披露:我是作者]使这个超级简单。它的PostJsonAsync方法负责序列化内容和设置内容类型报头，而ReceiveJson则反序列化响应。如果accept头是必需的，你需要自己设置，但Flurl提供了一个非常干净的方式来做到这一点:
using Flurl.Http;
var result = await "http://example.com/"
.WithHeader("Accept", "application/json")
.PostJsonAsync(new { ... })
.ReceiveJson<TResult>();
Flurl使用HttpClient和Json。它是一个PCL，所以它可以在各种平台上工作。
PM> Install-Package Flurl.Http
尝试使用TryAddWithoutValidation
var client = new HttpClient();
client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json; charset=utf-8");
. net试图强迫你遵守某些标准，即content - type头只能在有内容的请求上指定(例如POST, PUT等)。因此，正如其他人指出的那样，设置Content-Type报头的首选方法是通过HttpContent.Headers.ContentType属性。
话虽如此，某些Api(如截至2016-12-19的LiquidFiles Api)需要为GET请求设置Content-Type报头，. net不允许在请求本身设置此报头——即使使用TryAddWithoutValidation。此外，您不能为请求指定Content——即使它的长度为零。我唯一能避开这个问题的方法似乎就是诉诸于反思。代码(以防其他人需要它)是
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");
编辑:
正如注释中所指出的，该字段在不同版本的dll中有不同的名称。在GitHub的源代码中，该字段当前命名为s_invalidHeaders。这个例子已经根据@David Thompson的建议进行了修改。
一些关于。net Core的额外信息(在阅读了erdomke关于设置私有字段以在没有内容的请求上提供内容类型的文章后)…
在调试我的代码之后，我无法通过反射看到要设置的私有字段-所以我想我应该尝试重新创建这个问题。
我使用。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;
正如预期的那样，我得到了一个聚合异常，其内容为“无法发送具有此动词类型的内容体”。
然而，如果我用。net Core(1.1)做同样的事情-我不会得到异常。我的服务器应用程序非常高兴地回答了我的请求，并选择了内容类型。
我对此感到惊喜，我希望它能帮助到一些人!
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"));
这就是你所需要的。
使用Newtonsoft。Json，如果你需要一个内容为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();
}
}
好吧，它不是HTTPClient，但如果你能使用它，WebClient是相当简单的:
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(...);
}
我发现下面的方法最简单易懂:
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();
你可以用这个，它会工作!
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();
你需要这样做:
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;
为那些受困于字符集的人准备的
我有一个非常特殊的情况，服务提供商不接受字符集，他们拒绝改变子结构来允许它…… 不幸的是，HttpClient通过StringContent自动设置报头，不管你传递的是null还是Encoding。UTF8，它总是会设置字符集…
今天我在改变子系统的边缘;从HttpClient转向其他东西，我想到了一些东西…，为什么不用反射来清空“字符集”呢?.．. 在我尝试之前，我想到了一种方法，“也许我可以在初始化后改变它”，这是有效的。
下面是如何设置“application/json”头没有“;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;
注意:下面的空值无效，加";charset = utf - 8”
return new StringContent(jsonRequest, null, "application/json");
EDIT
@DesertFoxAZ建议也可以使用下面的代码，工作良好。(没有自己测试，如果它的工作率，并在评论中赞扬他)
stringContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
我也有类似的问题。 所以我发现Software PostMan可以在点击左上角的“code”按钮时生成代码。从中我们可以看到在“引擎盖下”发生了什么，HTTP调用是用许多代码语言生成的;curl命令，c# RestShart, java, nodeJs，…
这对我帮助很大，而不是使用。net基础HttpClient，我最终使用RestSharp nuget包。
希望能帮助到其他人!
尝试使用HttpClientFactory
services.AddSingleton<WebRequestXXX>()
.AddHttpClient<WebRequestXXX>("ClientX", config =>
{
config.BaseAddress = new System.Uri("https://jsonplaceholder.typicode.com");
config.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
config.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json; charset=utf-8");
});
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
public class WebRequestXXXX
{
private readonly IHttpClientFactory _httpClientFactory;
public WebRequestXXXX(IHttpClientFactory httpClientFactory)
{
_httpClientFactory = httpClientFactory;
}
public List<Posts> GetAllPosts()
{
using (var _client = _httpClientFactory.CreateClient("ClientX"))
{
var response = _client.GetAsync("/posts").Result;
if (response.IsSuccessStatusCode)
{
var itemString = response.Content.ReadAsStringAsync().Result;
var itemJson = System.Text.Json.JsonSerializer.Deserialize<List<Posts>>(itemString,
new System.Text.Json.JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
return itemJson;
}
else
{
return new List<Posts>();
}
}
}
}
微软似乎试图强迫开发人员遵循他们的标准，甚至没有提供任何选项或设置，特别是考虑到这是一个客户端，我们是由服务器端需求决定的，特别是考虑到微软服务器端框架本身需要它!
所以基本上微软试图强迫我们养成好习惯，当连接到他们的服务器技术时，强迫我们养成不好的习惯……
如果微软的任何人正在阅读这篇文章，那么请修复它…
无论哪种方式，对于任何需要Get等内容类型头的人来说，在旧的。net版本中，可以在https://stackoverflow.com/a/41231353/640195上使用@erdomke的答案，不幸的是，这在新的。net核心版本中不再适用。
下面的代码经过测试，可以与。net core 3.1一起工作，从GitHub上的源代码来看，它应该也可以与更新的。net版本一起工作。
private void FixContentTypeHeaders()
{
var assembly = typeof(System.Net.Http.Headers.HttpRequestHeaders).Assembly;
var assemblyTypes = assembly.GetTypes();
var knownHeaderType = assemblyTypes.FirstOrDefault(n => n.Name == "KnownHeader");
var headerTypeField = knownHeaderType?
.GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
.FirstOrDefault(n => n.Name.Contains("HeaderType"));
if (headerTypeField is null) return;
var headerTypeFieldType = headerTypeField.FieldType;
var newValue = Enum.Parse(headerTypeFieldType, "All");
var knownHeadersType = assemblyTypes.FirstOrDefault(n => n.Name == "KnownHeaders");
var contentTypeObj = knownHeadersType.GetFields().FirstOrDefault(n => n.Name == "ContentType").GetValue(null);
if (contentTypeObj is null) return;
headerTypeField.SetValue(contentTypeObj, newValue);
}
我用RestSharp得到了答案:
private async Task<string> GetAccessTokenAsync()
{
var client = new RestClient(_baseURL);
var request = new RestRequest("auth/v1/login", Method.POST, DataFormat.Json);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("x-api-key", _apiKey);
request.AddHeader("Accept-Language", "br");
request.AddHeader("x-client-tenant", "1");
...
}
这对我很管用。
对于那些想要专门将Content-Type设置为Json的人，你可以使用扩展方法PostAsJsonAsync。
using System.Net.Http.Json; //this is needed for PostAsJsonAsync to work
//....
HttpClient client = new HttpClient();
HttpResponseMessage response = await
client.PostAsJsonAsync("http://example.com/" + "relativeAddress",
new
{
name = "John Doe",
age = 33
});
//Do what you need to do with your response
这样做的好处是代码更简洁，并且可以避免字符串化的json。更多详情请访问:https://learn.microsoft.com/en-us/previous-versions/aspnet/hh944339(v=vs.118)
诀窍在于你可以设置各种标题，比如:
HttpRequestMessage request = new HttpRequestMessage();
request.Headers.Add("Accept-Language", "en"); //works OK
但不是任何标题。例如:
request.Headers.Add("Content-Type", "application/json");//wrong
将引发运行时异常“误用头名”。这似乎是可行的:
request.Headers.Add(
HttpRequestHeader.ContentType.ToString(), //useless
"application/json"
);
但是这样会产生一个名为ContentType的无用头，没有连字符。标头名称不区分大小写，但对连字符非常敏感。
解决方案是在将body添加到http请求的Content部分时声明body的编码和类型:
string Body = "...";
request.Content =
new StringContent(Body, Encoding.UTF8, "application/json");
只有这样，适用的http头才会自动添加到请求中:
Content-Type: application/json; charset=utf-8
在一台没有代理服务器的机器上，使用Fiddler很难发现这一点。Visual Studio曾经有一个网络工具，你可以在其中检查所有的头文件，但只能在版本2015，而不是在更新的版本2017或2022。如果使用调试器检查请求。头文件，你不会发现由StringContent()自动添加的头文件。
Api返回
"不支持的媒体类型"，"状态":415
添加ContentType到jsonstring做了魔法，这是我的脚本工作100%到今天为止
using (var client = new HttpClient())
{
var endpoint = "api/endpoint;
var userName = "xxxxxxxxxx";
var passwd = "xxxxxxxxxx";
var content = new StringContent(jsonString, Encoding.UTF8, "application/json");
var authToken = Encoding.ASCII.GetBytes($"{userName}:{passwd}");
client.BaseAddress = new Uri("https://example.com/");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authToken));
HttpResponseMessage response = await client.PostAsync(endpoint, content);
if (response.IsSuccessStatusCode)
{
// Get the URI of the created resource.
Uri returnUrl = response.Headers.Location;
Console.WriteLine(returnUrl);
}
string responseBody = await response.Content.ReadAsStringAsync();
return responseBody;
}
对于我的场景，第三方API正在创建HttpRequestMessage，因此我无法使用投票最多的答案来解决这个问题。我不喜欢干扰反射的想法所以其他答案也不成立。
相反，我从AndroidMessageHandler扩展，并使用这个新类作为HttpClient的参数。AndroidMessageHandler包含SendAsync方法，可以在HttpRequestMessage对象发送之前重写该方法。如果您没有访问Android Xamarin库的权限，您可以使用HttpMessageHandler来解决一些问题。
public class XamarinHttpMessageHandler : global::Xamarin.Android.Net.AndroidMessageHandler
{
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
// Here I make check that I'm only modifying a specific request
// and not all of them.
if (request.RequestUri != null && request.RequestUri.AbsolutePath.EndsWith("download") && request.Content != null)
{
request.Content.Headers.Add("Content-Type", "text/plain");
}
return base.SendAsync(request, cancellationToken);
}
}
然后使用:
var client = new HttpClient(new XamarinHttpMessageHandler());