System.Net.HttpClient get için sorgu dizesi oluşturun

System.Net.HttpClient kullanarak bir http alma isteği göndermek istiyorsanız, parametre eklemek için hiçbir api var gibi görünüyor, bu doğru mu?

Bir ad değeri toplama ve bunları kodlama url oluşturma ve sonra nihayet onları birleştirmek içermeyen sorgu dizesi oluşturmak için kullanılabilir herhangi bir basit API var mı? RestSharp'ın api (yani AddParameter (..)) gibi bir şey kullanmayı umuyordum

System.Net.HttpClient kullanarak bir http alma isteği göndermek istiyorsanız, parametre eklemek için hiçbir api var gibi görünüyor, bu doğru mu?

Evet.

Bir ad değeri toplama ve bunları kodlama url oluşturma ve sonra nihayet onları birleştirmek içermeyen sorgu dizesi oluşturmak için kullanılabilir herhangi bir basit API var mı?

Elbette:

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

size beklenen sonucu verecektir:

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

Ayrıca UriBuildersınıfı yararlı bulabilirsiniz :

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

size beklenen sonucu verecektir:

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

HttpClient.GetAsyncyönteminize güvenli bir şekilde besleyebileceğinizden emin olabilirsiniz .

Dahil etmek istemeyen olanlar için System.Webzaten bunu kullanmıyorum projelerde kullanabileceğiniz FormUrlEncodedContentgelen System.Net.Httpve aşağıdaki gibi bir şey yapmak:

keyvaluepair sürümü

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

sözlük sürümü

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: kabul edilen sürümü kullanmayın, çünkü unicode karakterlerin işlenmesiyle tamamen kırılmıştır ve asla dahili API kullanmaz

Aslında kabul edilen çözümle garip çift kodlama sorunu buldum:

Dolayısıyla, kodlanması gereken karakterlerle uğraşıyorsanız, kabul edilen çözüm çift kodlamaya yol açar:

• sorgu parametreleri NameValueCollectionindeksleyici kullanılarak otomatik olarak kodlanır ( ve bu kullanım UrlEncodeUnicode, normal beklenen değil UrlEncode(!) )
• Ardından, bir kez daha kodlama yapan bir yapıcı kullanarak uriBuilder.Uriyeni oluştururUri (normal url kodlaması)
• Bunu yaparakuriBuilder.ToString() (bu, UriIMO'nun en azından tutarsızlık, belki bir hata, ancak bu başka bir soru olduğu doğru döndürülse de) ve ardından HttpClientdize kabul eden yöntemi kullanarak - istemci yine Uride şu şekilde geçirilen dizeden oluşturur :new Uri(uri, UriKind.RelativeOrAbsolute)

Küçük ama tam repro:

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!

Çıktı:

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

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

Gördüğünüz gibi, uribuilder.ToString()+ httpClient.GetStringAsync(string)veya uriBuilder.Uri+ yaparsanız yapınhttpClient.GetStringAsync(Uri) yaparsanız yapın, çift kodlanmış parametre gönderirsiniz

Sabit örnek şunlar olabilir:

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

Ama bu kullanır eskimiş Uri yapıcısı

PS, Windows Server'daki en son Uri.NET'imde, bool doc yorumuna sahip yapıcı "eski, dontEscape her zaman yanlıştır" diyor, ancak aslında beklendiği gibi çalışıyor (kaçıyor)

Yani başka bir hata gibi görünüyor ...

Ve bu bile yanlıştır - UrlEncodedUnicode'u sunucuya gönderir, sadece UrlEncoded sunucunun beklediği gibi değil

Güncelleme: bir şey daha var, NameValueCollection aslında artık kullanılmaması gereken ve normal url.encode / decode ile uyumsuz olan UrlEncodeUnicode yapıyor (bkz . URL Sorgusu için NameValueCollection? ).

İşin özü Yani: Bu kesmek kullanmak aslaNameValueCollection query = HttpUtility.ParseQueryString(builder.Query); sizin unicode sorgu parametreleri karmaşa olacak şekilde. Sorguyu manuel olarak derleyin ve UriBuilder.Querygerekli kodlamayı yapacak olan atamayı yapın ve ardından Uri'yi kullanın UriBuilder.Uri.

Bunun gibi kullanılması gerekmeyen kodu kullanarak kendinizi incitmenin ana örneği

ASP.NET Core projesinde QueryHelpers sınıfını kullanabilirsiniz.

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

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

Flurl'a göz atmak isteyebilirsiniz .

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

Daha fazla bilgi için dokümanlara göz atın . Tam paket NuGet'te mevcuttur:

PM> Install-Package Flurl.Http

veya yalnızca bağımsız URL oluşturucu:

PM> Install-Package Flurl

Rostov'un gönderisiyle aynı satırlar boyunca, System.Webprojenize bir referans eklemek istemiyorsanız FormDataCollection,System.Net.Http.Formatting ve aşağıdaki gibi bir şey yapmak:

kullanma 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 ilginç ve akıllı bir çözüm sundu ve işte başka bir seçenek olabilecek bir şey var:

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

ve bunu kullanırken, bunu yapabilirsiniz:

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

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

Veya sadece Uri uzantımı kullanarak

kod

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

kullanım

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

Sonuç

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

Geliştirdiğim RFC 6570 URI Şablon kütüphanesi bu işlemi gerçekleştirebilir. Tüm kodlama bu RFC'ye göre sizin için yapılır. Bu yazı yazıldığı sırada beta sürümü mevcuttur ve kararlı bir 1.0 sürümü olarak değerlendirilmemesinin tek nedeni, belgelerin beklentilerimi tam olarak karşılamamasıdır (bkz. # 17 , # 18 , # 32 , # 43 ).

Yalnızca bir sorgu dizesi oluşturabilirsiniz:

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

Veya tam bir URI oluşturabilirsiniz:

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

Bu birkaç kez yeniden kullanmak zorunda olduğundan, sadece sorgu dizesinin nasıl oluşturulduğunu soyutlamak için yardımcı olan bu sınıf ile geldi.

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

}

Kullanım böyle bir şeye basitleştirilecektir:

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

uri döndürür: http://example.com/?foo=bar%3c%3e%26-baz&bar=second

Taras.roshko'nun cevabında açıklanan çift kodlama sorununu önlemek ve sorgu parametreleriyle kolayca çalışabilmek için uriBuilder.Uri.ParseQueryString()bunun yerine kullanabilirsiniz HttpUtility.ParseQueryString().

Kabul edilen yanıtın iyi bir parçası, HttpUtility.ParseQueryString () yerine UriBuilder.Uri.ParseQueryString () kullanacak şekilde değiştirildi:

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" sayesinde, Bu uzatma yöntemleridir.

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

Bir sözlüğü QueryStringFormat dönüştürmek için bir uzantı yöntemi oluşturmaktan daha iyi bir çözüm bulamadım. Waleed AK tarafından önerilen çözüm de iyidir.

Çözümümü takip et:

Uzantı yöntemini oluşturun:

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

Ve onları:

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"