Xây dựng chuỗi truy vấn cho System.Net.HttpClient get

Nếu tôi muốn gửi một yêu cầu nhận http bằng System.Net.HttpClient dường như không có api để thêm tham số, điều này có đúng không?

Có bất kỳ api đơn giản nào có sẵn để xây dựng chuỗi truy vấn không liên quan đến việc xây dựng bộ sưu tập giá trị tên và mã hóa url và cuối cùng là nối chúng không? Tôi đã hy vọng sử dụng một cái gì đó như api của RestSharp (tức là AddParameter (..))

Nếu tôi muốn gửi một yêu cầu nhận http bằng System.Net.HttpClient dường như không có api để thêm tham số, điều này có đúng không?

Đúng.

Có bất kỳ api đơn giản nào có sẵn để xây dựng chuỗi truy vấn không liên quan đến việc xây dựng bộ sưu tập giá trị tên và mã hóa url và cuối cùng là nối chúng không?

Chắc chắn rồi:

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

sẽ cho bạn kết quả như mong đợi:

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

Bạn cũng có thể tìm thấy UriBuilderlớp hữu ích:

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

sẽ cho bạn kết quả như mong đợi:

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

rằng bạn có thể cung cấp nhiều hơn một cách an toàn cho HttpClient.GetAsyncphương pháp của bạn .

Đối với những người không muốn bao gồm System.Webtrong các dự án mà chưa sử dụng nó, bạn có thể sử dụng FormUrlEncodedContenttừ System.Net.Httpvà làm điều gì đó như sau:

phiên bản keyvaluepair

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

phiên bản từ điển

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: không sử dụng phiên bản được chấp nhận vì nó hoàn toàn bị hỏng liên quan đến việc xử lý các ký tự unicode và không bao giờ sử dụng API nội bộ

Tôi thực sự đã tìm thấy vấn đề mã hóa kép kỳ lạ với giải pháp được chấp nhận:

Vì vậy, nếu bạn đang xử lý các ký tự cần được mã hóa, giải pháp được chấp nhận sẽ dẫn đến mã hóa kép:

• tham số truy vấn được tự động mã hóa bằng cách sử dụng bộ NameValueCollectionchỉ mục ( và điều này sử dụng UrlEncodeUnicode, không được mong đợi thường xuyên UrlEncode(!) )
• Sau đó, khi bạn gọi uriBuilder.Urinó sẽ tạo mới Uribằng cách sử dụng hàm tạo , mã hóa thêm một lần nữa (mã hóa url thông thường)
• Điều đó không thể tránh được bằng cách thực hiệnuriBuilder.ToString() (mặc dù điều này trả về chính xác UriIMO ít nhất là không nhất quán, có thể là một lỗi, nhưng đó là một câu hỏi khác) và sau đó sử dụng HttpClientchuỗi chấp nhận phương thức - client vẫn tạo Urira chuỗi đã truyền của bạn như thế này:new Uri(uri, UriKind.RelativeOrAbsolute)

Nhỏ, nhưng repro đầy đủ:

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!

Đầu ra:

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

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

Như bạn có thể thấy, bất kể bạn làm uribuilder.ToString()+ httpClient.GetStringAsync(string)hay uriBuilder.Uri+ httpClient.GetStringAsync(Uri)cuối cùng bạn sẽ gửi tham số được mã hóa kép

Ví dụ cố định có thể là:

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

Nhưng điều này sử dụng lỗi thời Uri constructor

PS trên .NET mới nhất của tôi trên Windows Server, nhà Urixây dựng với nhận xét bool doc nói "lỗi thời, dontEscape luôn sai", nhưng thực sự hoạt động như mong đợi (bỏ qua thoát)

Vì vậy, nó trông giống như một lỗi khác ...

Và thậm chí điều này hoàn toàn sai - nó gửi UrlEncodingUnicode đến máy chủ, không chỉ UrlEncoding những gì máy chủ mong đợi

Cập nhật: một điều nữa là, NameValueCollection thực sự có UrlEncodeUnicode, không được sử dụng nữa và không tương thích với url.encode / giải mã thông thường (xem NameValueCollection để truy vấn URL? ).

Vì vậy, điểm mấu chốt là: không bao giờ sử dụng bản hack nàyNameValueCollection query = HttpUtility.ParseQueryString(builder.Query); vì nó sẽ làm rối các tham số truy vấn unicode của bạn. Chỉ cần xây dựng truy vấn theo cách thủ công và gán nó vào UriBuilder.Queryđó sẽ thực hiện mã hóa cần thiết và sau đó nhận Uri bằng cách sử dụng UriBuilder.Uri.

Ví dụ điển hình về việc tự làm tổn thương chính mình bằng cách sử dụng mã không được sử dụng như thế này

Trong dự án ASP.NET Core, bạn có thể sử dụng lớp QueryHelpers.

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

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

Bạn có thể muốn kiểm tra Flurl [tiết lộ: Tôi là tác giả], một người xây dựng URL thông thạo với lib đồng hành tùy chọn mở rộng nó thành một ứng dụng REST đầy đủ.

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

Kiểm tra các tài liệu để biết thêm chi tiết. Gói đầy đủ có sẵn trên NuGet:

PM> Install-Package Flurl.Http

hoặc chỉ là trình tạo URL độc lập:

PM> Install-Package Flurl

Dọc theo dòng giống như bài Rostov, nếu bạn không muốn bao gồm một tham chiếu đến System.Webtrong dự án của bạn, bạn có thể sử dụng FormDataCollectiontừ System.Net.Http.Formattingvà làm điều gì đó như sau:

Sử dụng 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 đưa ra một giải pháp thú vị và thông minh, và đây là một điều có thể là một lựa chọn khác:

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

và vì vậy khi sử dụng nó, bạn có thể làm điều này:

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

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

Hoặc đơn giản là sử dụng tiện ích mở rộng Uri của tôi

Mã

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

Sử dụng

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

Kết quả

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

Các RFC 6570 URI Template thư viện Tôi đang phát triển có khả năng thực hiện hoạt động này. Tất cả mã hóa được xử lý cho bạn theo RFC đó. Tại thời điểm viết bài này, bản phát hành beta đã có sẵn và lý do duy nhất nó không được coi là bản phát hành 1.0 ổn định là tài liệu không đáp ứng đầy đủ mong đợi của tôi (xem các vấn đề # 17 , # 18 , # 32 , # 43 ).

Bạn có thể xây dựng một chuỗi truy vấn một mình:

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

Hoặc bạn có thể xây dựng một URI hoàn chỉnh:

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

Vì tôi phải sử dụng lại vài lần, tôi đã nghĩ ra lớp này chỉ đơn giản là giúp trừu tượng hóa cách chuỗi truy vấn được tạo.

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

}

Việc sử dụng sẽ được đơn giản hóa thành một cái gì đó như thế này:

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

điều đó sẽ trả về uri: http://example.com/?foo=bar%3c%3e%26-baz&bar=second

Để tránh vấn đề mã hóa kép được mô tả trong câu trả lời của taras.roshko và để giữ khả năng dễ dàng làm việc với các tham số truy vấn, bạn có thể sử dụng uriBuilder.Uri.ParseQueryString()thay vì HttpUtility.ParseQueryString().

Một phần tốt của câu trả lời được chấp nhận, được sửa đổi để sử dụng UriBuilder.Uri.PudeQueryString () thay vì httpUtility.PudeQueryString ():

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

Nhờ "Darin Dimitrov", Đây là phương thức mở rộng.

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

Tôi không thể tìm thấy giải pháp nào tốt hơn là tạo phương thức mở rộng để chuyển đổi Từ điển sang QueryStringFormat. Giải pháp được đề xuất bởi Waleed AK là tốt.

Thực hiện theo giải pháp của tôi:

Tạo phương thức mở rộng:

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

Và họ:

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"