Zbuduj ciąg zapytania dla System.Net.HttpClient get

Jeśli chcę przesłać żądanie HTTP get za pomocą System.Net.HttpClient, wydaje się, że nie ma interfejsu API do dodawania parametrów, czy to prawda?

Czy jest dostępny jakiś prosty interfejs API do zbudowania ciągu zapytania, który nie wymaga zbudowania kolekcji wartości nazw i adresu URL kodującego je, a następnie ich konkatenacji? Miałem nadzieję użyć czegoś takiego jak API RestSharp (tj. AddParameter (..))

Jeśli chcę przesłać żądanie HTTP get za pomocą System.Net.HttpClient, wydaje się, że nie ma interfejsu API do dodawania parametrów, czy to prawda?

Tak.

Czy jest dostępny jakiś prosty interfejs API do zbudowania ciągu zapytania, który nie wymaga zbudowania kolekcji wartości nazw i adresu URL kodującego je, a następnie ich konkatenacji?

Pewnie:

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

da ci oczekiwany wynik:

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

Może się również UriBuilderprzydać klasa:

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

da ci oczekiwany wynik:

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

że możesz bardziej niż bezpiecznie karmić swoją HttpClient.GetAsyncmetodę.

Dla tych, którzy nie chcą zawierać System.Webw projektach, które nie korzystają już go można użyć FormUrlEncodedContentod System.Net.Httpi zrobić coś jak poniżej:

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

wersja słownikowa

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: nie używaj zaakceptowanej wersji, ponieważ jest całkowicie zepsuta w związku z obsługą znaków Unicode i nigdy nie używaj wewnętrznego API

Znalazłem dziwny problem podwójnego kodowania z zaakceptowanym rozwiązaniem:

Jeśli więc masz do czynienia ze znakami, które muszą zostać zakodowane, zaakceptowane rozwiązanie prowadzi do podwójnego kodowania:

• parametry zapytania są automatycznie kodowane przy użyciu NameValueCollectionindeksatora ( i używa tego UrlEncodeUnicode, nie jest to normalnie oczekiwane UrlEncode(!) )
• Następnie po wywołaniu uriBuilder.Uritworzy nowy Uriza pomocą konstruktora, który koduje jeszcze raz (normalne kodowanie adresu URL)
• Tego nie da się uniknąć poprzez zrobienieuriBuilder.ToString() (nawet jeśli to zwraca poprawne, Uriktóra IMO jest co najmniej niespójnością, być może błędem, ale to kolejne pytanie), a następnie za pomocą HttpClientmetody akceptującej ciąg - klient nadal tworzy Uriz przekazanego ciągu w następujący sposób:new Uri(uri, UriKind.RelativeOrAbsolute)

Małe, ale pełne 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!

Wynik:

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

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

Jak widać, bez względu na to, czy zrobisz uribuilder.ToString()+ httpClient.GetStringAsync(string)lub uriBuilder.Uri+ httpClient.GetStringAsync(Uri), ostatecznie wyślesz podwójnie zakodowany parametr

Naprawionym przykładem może być:

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

Ale używa to przestarzałego Uri konstruktora

PS w moim najnowszym .NET na Windows Server, Urikonstruktor z komentarzem bool doc mówi „przestarzały, dontEscape jest zawsze fałszywy”, ale w rzeczywistości działa zgodnie z oczekiwaniami (pomija ucieczkę)

Wygląda to na kolejny błąd ...

I nawet to jest po prostu źle - wysyła UrlEncodedUnicode do serwera, a nie tylko UrlEncoded, czego oczekuje serwer

Aktualizacja: jeszcze jedno: NameValueCollection faktycznie wykonuje UrlEncodeUnicode, którego nie należy już używać i jest niezgodny ze zwykłym url.encode / decode (patrz NameValueCollection do zapytania URL? ).

Więc sedno brzmi: nigdy nie używaj tego hacka,NameValueCollection query = HttpUtility.ParseQueryString(builder.Query); ponieważ spowoduje to bałagan parametrów zapytania unicode. Wystarczy zbudować zapytanie ręcznie i przypisać je do tego, UriBuilder.Queryktóre wykona niezbędne kodowanie, a następnie użyje Uri UriBuilder.Uri.

Doskonały przykład zranienia się za pomocą kodu, którego nie należy używać w ten sposób

W projekcie ASP.NET Core można użyć klasy QueryHelpers.

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

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

Możesz wypróbować Flurl [ujawnienie: jestem autorem], płynnego narzędzia do tworzenia adresów URL z opcjonalną biblioteką towarzyszącą, która rozszerza go na pełnoprawnego klienta 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>();

Sprawdź dokumenty, aby uzyskać więcej informacji. Pełny pakiet jest dostępny na NuGet:

PM> Install-Package Flurl.Http

lub po prostu samodzielny program do tworzenia adresów URL:

PM> Install-Package Flurl

Według tych samych zasad jak słupka Rostowa, jeśli nie chcą zawierać odniesienie do System.Webw projekcie, można korzystać FormDataCollectionz System.Net.Http.Formattingi zrobić coś jak następuje:

Za pomocą 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 zaoferował ciekawe i sprytne rozwiązanie, a oto coś, co może być inną opcją:

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

i podczas korzystania z niego możesz to zrobić:

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

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

Lub po prostu używając mojego rozszerzenia Uri

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

Stosowanie

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

Wynik

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

RFC 6570 URI Template Library Zajmuję jest zdolny do wykonywania tej operacji. Wszystkie kodowania są obsługiwane zgodnie z RFC. W chwili pisania tego tekstu dostępna jest wersja beta, a jedynym powodem, dla którego nie jest uważana za stabilną wersję 1.0, jest to, że dokumentacja nie w pełni spełnia moje oczekiwania (patrz numery 17 , 18 , 32 , 43 ).

Możesz zbudować ciąg zapytania sam:

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

Lub możesz zbudować pełny 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);

Ponieważ muszę użyć tego czasu kilka razy, wymyśliłem tę klasę, która po prostu pomaga wyodrębnić sposób tworzenia ciągu zapytania.

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

}

Użycie zostanie uproszczone do czegoś takiego:

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

, który zwróci identyfikator: http://example.com/?foo=bar%3c%3e%26-baz&bar=second

Aby uniknąć problemu podwójnego kodowania opisanego w odpowiedzi na taras.roshko i zachować możliwość łatwej pracy z parametrami zapytania, możesz użyć uriBuilder.Uri.ParseQueryString()zamiast HttpUtility.ParseQueryString().

Dobra część zaakceptowanej odpowiedzi, zmodyfikowana do użycia UriBuilder.Uri.ParseQueryString () zamiast 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();

Dzięki „Darin Dimitrov”, To są metody rozszerzenia.

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

Nie mogłem znaleźć lepszego rozwiązania niż stworzenie metody rozszerzenia do konwersji słownika na QueryStringFormat. Rozwiązanie zaproponowane przez Waleed AK jest również dobre.

Postępuj zgodnie z moim rozwiązaniem:

Utwórz metodę rozszerzenia:

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

I oni:

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"