建立System.Net.HttpClient get的查询字符串

如果我希望使用System.Net.HttpClient提交http get请求，似乎没有用于添加参数的api，这是正确的吗？

是否有任何简单的API可以用来构建查询字符串，而无需构建名称值集合并对其进行url编码，然后最终将它们串联起来？我希望使用类似RestSharp的api的东西（即AddParameter（..））

如果我希望使用System.Net.HttpClient提交http get请求，似乎没有用于添加参数的api，这是正确的吗？

是。

是否有任何简单的API可以用来构建查询字符串，而无需构建名称值集合并对其进行url编码，然后最终将它们串联起来？

当然：

var query = HttpUtility.ParseQueryString(string.Empty);
query["foo"] = "bar<>&-baz";
query["bar"] = "bazinga";
string queryString = query.ToString();

将给您预期的结果：

foo=bar%3c%3e%26-baz&bar=bazinga

您可能还会发现UriBuilder该类有用：

var builder = new UriBuilder("http://example.com");
builder.Port = -1;
var query = HttpUtility.ParseQueryString(builder.Query);
query["foo"] = "bar<>&-baz";
query["bar"] = "bazinga";
builder.Query = query.ToString();
string url = builder.ToString();

将给您预期的结果：

http://example.com/?foo=bar%3c%3e%26-baz&bar=bazinga

您可以更加安全地使用您的HttpClient.GetAsync方法。

对于那些不想包含System.Web在尚未使用它的项目中的人，可以使用FormUrlEncodedContentfrom System.Net.Http并执行以下操作：

键值对版本

string query;
using(var content = new FormUrlEncodedContent(new KeyValuePair<string, string>[]{
    new KeyValuePair<string, string>("ham", "Glazed?"),
    new KeyValuePair<string, string>("x-men", "Wolverine + Logan"),
    new KeyValuePair<string, string>("Time", DateTime.UtcNow.ToString()),
})) {
    query = content.ReadAsStringAsync().Result;
}

字典版本

string query;
using(var content = new FormUrlEncodedContent(new Dictionary<string, string>()
{
    { "ham", "Glaced?"},
    { "x-men", "Wolverine + Logan"},
    { "Time", DateTime.UtcNow.ToString() },
})) {
    query = content.ReadAsStringAsync().Result;
}

TL; DR：请勿使用接受的版本，因为它在处理Unicode字符方面已完全中断，并且永远不要使用内部API

我实际上在接受的解决方案中发现了奇怪的双重编码问题：

因此，如果您要处理需要编码的字符，那么公认的解决方案将导致双重编码：

• 查询参数是通过使用NameValueCollection索引器自动编码的（并且使用UrlEncodeUnicode，而不是常规的预期UrlEncode（！））
• 然后，当您调用uriBuilder.Uri它时，Uri使用构造函数创建新的函数，该函数会再编码一次（正常的url编码）
• 这样做是无法避免的uriBuilder.ToString()（即使这会返回正确的结果Uri，即哪个IMO至少是不一致的，可能是一个错误，但这是另一个问题），然后使用HttpClient方法接受字符串- 客户端仍然会Uri像这样通过您传递的字符串来创建：new Uri(uri, UriKind.RelativeOrAbsolute)

小但完整的复制：

var builder = new UriBuilder
{
    Scheme = Uri.UriSchemeHttps,
    Port = -1,
    Host = "127.0.0.1",
    Path = "app"
};

NameValueCollection query = HttpUtility.ParseQueryString(builder.Query);

query["cyrillic"] = "кирилиця";

builder.Query = query.ToString();
Console.WriteLine(builder.Query); //query with cyrillic stuff UrlEncodedUnicode, and that's not what you want

var uri = builder.Uri; // creates new Uri using constructor which does encode and messes cyrillic parameter even more
Console.WriteLine(uri);

// this is still wrong:
var stringUri = builder.ToString(); // returns more 'correct' (still `UrlEncodedUnicode`, but at least once, not twice)
new HttpClient().GetStringAsync(stringUri); // this creates Uri object out of 'stringUri' so we still end up sending double encoded cyrillic text to server. Ouch!

输出：

?cyrillic=%u043a%u0438%u0440%u0438%u043b%u0438%u0446%u044f

https://127.0.0.1/app?cyrillic=%25u043a%25u0438%25u0440%25u0438%25u043b%25u0438%25u0446%25u044f

如您所见，无论您执行uribuilder.ToString()+ httpClient.GetStringAsync(string)还是uriBuilder.Uri+ httpClient.GetStringAsync(Uri)，最终都将发送双编码参数

固定的示例可能是：

var uri = new Uri(builder.ToString(), dontEscape: true);
new HttpClient().GetStringAsync(uri);

但这使用了过时的 Uri构造函数

我在Windows Server上最新的.NET上的PS，Uri带有bool doc注释的构造函数表示“已过时，dontEscape始终为false”，但实际上按预期工作（跳过转义）

所以看起来像是另一个错误...

甚至这是完全错误的-它向服务器发送UrlEncodedUnicode，而不仅仅是服务器期望的UrlEncoded

更新：还有一件事是，NameValueCollection实际上是UrlEncodeUnicode，它不应该再使用了，并且与常规的url.encode / decode不兼容（请参阅NameValueCollection到URL Query？）。

因此，最重要的是：永远不要使用此技巧，NameValueCollection query = HttpUtility.ParseQueryString(builder.Query);因为它会弄乱您的unicode查询参数。只需手动构建查询并将其分配给UriBuilder.Query将进行必要编码的查询，然后使用即可获取Uri UriBuilder.Uri。

通过使用不应像这样使用的代码来伤害自己的主要示例

在ASP.NET Core项目中，可以使用QueryHelpers类。

// using Microsoft.AspNetCore.WebUtilities;
var query = new Dictionary<string, string>
{
    ["foo"] = "bar",
    ["foo2"] = "bar2",
    // ...
};

var response = await client.GetAsync(QueryHelpers.AddQueryString("/api/", query));

您可能想看看Flurl [公开：我是作者]，这是一个流畅的URL构建器，带有可选的伴随库，可将其扩展为功能完善的REST客户端。

var result = await "https://api.com"
    // basic URL building:
    .AppendPathSegment("endpoint")
    .SetQueryParams(new {
        api_key = ConfigurationManager.AppSettings["SomeApiKey"],
        max_results = 20,
        q = "Don't worry, I'll get encoded!"
    })
    .SetQueryParams(myDictionary)
    .SetQueryParam("q", "overwrite q!")

    // extensions provided by Flurl.Http:
    .WithOAuthBearerToken("token")
    .GetJsonAsync<TResult>();

查看文档以获取更多详细信息。完整的软件包可在NuGet上找到：

PM> Install-Package Flurl.Http

或只是独立的URL构建器：

PM> Install-Package Flurl

与Rostov的帖子一样，如果您不想System.Web在项目中包含对它的引用，则可以使用FormDataCollectionfrom System.Net.Http.Formatting并执行以下操作：

使用 System.Net.Http.Formatting.FormDataCollection

var parameters = new Dictionary<string, string>()
{
    { "ham", "Glaced?" },
    { "x-men", "Wolverine + Logan" },
    { "Time", DateTime.UtcNow.ToString() },
}; 
var query = new FormDataCollection(parameters).ReadAsNameValueCollection().ToString();

Darin提供了一个有趣且聪明的解决方案，以下是另一种选择：

public class ParameterCollection
{
    private Dictionary<string, string> _parms = new Dictionary<string, string>();

    public void Add(string key, string val)
    {
        if (_parms.ContainsKey(key))
        {
            throw new InvalidOperationException(string.Format("The key {0} already exists.", key));
        }
        _parms.Add(key, val);
    }

    public override string ToString()
    {
        var server = HttpContext.Current.Server;
        var sb = new StringBuilder();
        foreach (var kvp in _parms)
        {
            if (sb.Length > 0) { sb.Append("&"); }
            sb.AppendFormat("{0}={1}",
                server.UrlEncode(kvp.Key),
                server.UrlEncode(kvp.Value));
        }
        return sb.ToString();
    }
}

因此，在使用它时，您可以这样做：

var parms = new ParameterCollection();
parms.Add("key", "value");

var url = ...
url += "?" + parms;

或者只是使用我的Uri扩展程序

码

public static Uri AttachParameters(this Uri uri, NameValueCollection parameters)
{
    var stringBuilder = new StringBuilder();
    string str = "?";
    for (int index = 0; index < parameters.Count; ++index)
    {
        stringBuilder.Append(str + parameters.AllKeys[index] + "=" + parameters[index]);
        str = "&";
    }
    return new Uri(uri + stringBuilder.ToString());
}

用法

Uri uri = new Uri("http://www.example.com/index.php").AttachParameters(new NameValueCollection
                                                                           {
                                                                               {"Bill", "Gates"},
                                                                               {"Steve", "Jobs"}
                                                                           });

结果

http://www.example.com/index.php?Bill=Gates&Steve=Jobs

我正在开发的RFC 6570 URI模板库能够执行此操作。所有编码均根据该RFC为您处理。在撰写本文时，beta版本已经可用，并且不被认为是稳定的1.0版本的唯一原因是该文档无法完全满足我的期望（请参阅问题＃17，＃18，＃32，＃43）。

您可以单独构建查询字符串：

UriTemplate template = new UriTemplate("{?params*}");
var parameters = new Dictionary<string, string>
  {
    { "param1", "value1" },
    { "param2", "value2" },
  };
Uri relativeUri = template.BindByName(parameters);

或者，您可以构建完整的URI：

UriTemplate template = new UriTemplate("path/to/item{?params*}");
var parameters = new Dictionary<string, string>
  {
    { "param1", "value1" },
    { "param2", "value2" },
  };
Uri baseAddress = new Uri("http://www.example.com");
Uri relativeUri = template.BindByName(baseAddress, parameters);

由于必须重用这几次，因此提出了此类，该类仅用于抽象查询字符串的组成方式。

public class UriBuilderExt
{
    private NameValueCollection collection;
    private UriBuilder builder;

    public UriBuilderExt(string uri)
    {
        builder = new UriBuilder(uri);
        collection = System.Web.HttpUtility.ParseQueryString(string.Empty);
    }

    public void AddParameter(string key, string value) {
        collection.Add(key, value);
    }

    public Uri Uri{
        get
        {
            builder.Query = collection.ToString();
            return builder.Uri;
        }
    }

}

使用将简化为以下内容：

var builder = new UriBuilderExt("http://example.com/");
builder.AddParameter("foo", "bar<>&-baz");
builder.AddParameter("bar", "second");
var uri = builder.Uri;

这将返回uri：http : //example.com/? foo= bar% 3c%3e%26-baz&bar= second

为了避免taras.roshko的答案中描述的双重编码问题，并保持轻松使用查询参数的可能性，可以使用uriBuilder.Uri.ParseQueryString()代替HttpUtility.ParseQueryString()。

可接受答案的好一部分，已修改为使用UriBuilder.Uri.ParseQueryString（）而不是HttpUtility.ParseQueryString（）：

var builder = new UriBuilder("http://example.com");
var query = builder.Uri.ParseQueryString();
query["foo"] = "bar<>&-baz";
query["bar"] = "bazinga";
builder.Query = query.ToString();
string url = builder.ToString();

感谢“ Darin Dimitrov”，这是扩展方法。

 public static partial class Ext
{
    public static Uri GetUriWithparameters(this Uri uri,Dictionary<string,string> queryParams = null,int port = -1)
    {
        var builder = new UriBuilder(uri);
        builder.Port = port;
        if(null != queryParams && 0 < queryParams.Count)
        {
            var query = HttpUtility.ParseQueryString(builder.Query);
            foreach(var item in queryParams)
            {
                query[item.Key] = item.Value;
            }
            builder.Query = query.ToString();
        }
        return builder.Uri;
    }

    public static string GetUriWithparameters(string uri,Dictionary<string,string> queryParams = null,int port = -1)
    {
        var builder = new UriBuilder(uri);
        builder.Port = port;
        if(null != queryParams && 0 < queryParams.Count)
        {
            var query = HttpUtility.ParseQueryString(builder.Query);
            foreach(var item in queryParams)
            {
                query[item.Key] = item.Value;
            }
            builder.Query = query.ToString();
        }
        return builder.Uri.ToString();
    }
}

除了创建将字典转换为QueryStringFormat的扩展方法外，我找不到更好的解决方案。Waleed AK提出的解决方案也很好。

按照我的解决方案：

创建扩展方法：

public static class DictionaryExt
{
    public static string ToQueryString<TKey, TValue>(this Dictionary<TKey, TValue> dictionary)
    {
        return ToQueryString<TKey, TValue>(dictionary, "?");
    }

    public static string ToQueryString<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, string startupDelimiter)
    {
        string result = string.Empty;
        foreach (var item in dictionary)
        {
            if (string.IsNullOrEmpty(result))
                result += startupDelimiter; // "?";
            else
                result += "&";

            result += string.Format("{0}={1}", item.Key, item.Value);
        }
        return result;
    }
}

还有他们：

var param = new Dictionary<string, string>
          {
            { "param1", "value1" },
            { "param2", "value2" },
          };
param.ToQueryString(); //By default will add (?) question mark at begining
//"?param1=value1&param2=value2"
param.ToQueryString("&"); //Will add (&)
//"&param1=value1&param2=value2"
param.ToQueryString(""); //Won't add anything
//"param1=value1&param2=value2"