Erstellen Sie eine Abfragezeichenfolge für System.Net.HttpClient get

Wenn ich eine http get-Anfrage mit System.Net.HttpClient senden möchte, scheint es keine API zum Hinzufügen von Parametern zu geben. Ist dies korrekt?

Gibt es eine einfache API zum Erstellen der Abfragezeichenfolge, bei der keine Namenswertsammlung und URL-Codierung erstellt und diese schließlich verkettet werden? Ich hatte gehofft, so etwas wie RestSharps API zu verwenden (dh AddParameter (..))

Wenn ich eine http get-Anfrage mit System.Net.HttpClient senden möchte, scheint es keine API zum Hinzufügen von Parametern zu geben. Ist dies korrekt?

Ja.

Gibt es eine einfache API zum Erstellen der Abfragezeichenfolge, bei der keine Namenswertsammlung und URL-Codierung erstellt und diese schließlich verkettet werden?

Sicher:

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

gibt Ihnen das erwartete Ergebnis:

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

Möglicherweise finden Sie die UriBuilderKlasse auch nützlich:

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

gibt Ihnen das erwartete Ergebnis:

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

dass Sie Ihre HttpClient.GetAsyncMethode mehr als sicher füttern könnten .

Für diejenigen , die nicht berücksichtigt werden sollen System.Webnicht bereits in Projekte , die Sie verwenden, können Sie FormUrlEncodedContentaus System.Net.Httpund etwas tun , wie folgt aus :

keyvaluepair version

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

Wörterbuchversion

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: Verwenden Sie keine akzeptierte Version, da diese in Bezug auf die Behandlung von Unicode-Zeichen völlig fehlerhaft ist, und verwenden Sie niemals die interne API

Ich habe tatsächlich ein seltsames Problem mit der doppelten Codierung bei der akzeptierten Lösung festgestellt:

Wenn Sie also mit Zeichen arbeiten, die codiert werden müssen, führt eine akzeptierte Lösung zu einer doppelten Codierung:

• Abfrageparameter werden mithilfe des NameValueCollectionIndexers automatisch codiert ( und dies verwendet UrlEncodeUnicodenicht regelmäßig erwartet UrlEncode(!) ).
• Wenn Sie dann aufrufen uriBuilder.Uri, wird ein neuer UriKonstruktor erstellt, der die Codierung noch einmal ausführt (normale URL-Codierung).
• uriBuilder.ToString()Dies kann nicht vermieden werden, indem Sie (obwohl dies korrekt zurückgibt, Uriwelche IMO zumindest inkonsistent ist, möglicherweise ein Fehler, aber das ist eine andere Frage) und dann eine HttpClientMethode verwenden, die eine Zeichenfolge akzeptiert - der Client erstellt immer noch Uriaus Ihrer übergebenen Zeichenfolge Folgendes:new Uri(uri, UriKind.RelativeOrAbsolute)

Kleiner, aber voller 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!

Ausgabe:

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

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

Wie Sie vielleicht sehen, egal ob Sie uribuilder.ToString()+ httpClient.GetStringAsync(string)oder uriBuilder.Uri+ tunhttpClient.GetStringAsync(Uri) senden Sie , doppelt codierte Parameter

Ein behobenes Beispiel könnte sein:

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

Dies verwendet jedoch einen veralteten Uri Konstruktor

PS in meinem neuesten .NET unter Windows Server, UriKonstruktor mit bool doc Kommentar sagt "veraltet, dontEscape ist immer falsch", funktioniert aber tatsächlich wie erwartet (überspringt das Escapezeichen)

Es sieht also nach einem weiteren Fehler aus ...

Und selbst das ist einfach falsch - es sendet UrlEncodedUnicode an den Server, nicht nur UrlEncoded, was der Server erwartet

Update: Eine weitere Sache ist, dass NameValueCollection tatsächlich UrlEncodeUnicode ausführt, das nicht mehr verwendet werden soll und nicht mit regulärem url.encode / decode kompatibel ist (siehe NameValueCollection to URL Query? ).

Das Fazit lautet also: Verwenden Sie diesen Hack niemals,NameValueCollection query = HttpUtility.ParseQueryString(builder.Query); da dies Ihre Unicode-Abfrageparameter durcheinander bringt. Erstellen Sie die Abfrage einfach manuell und weisen Sie sie UriBuilder.Queryder erforderlichen Codierung zu, und verwenden Sie dann UriUriBuilder.Uri .

Paradebeispiel dafür, wie Sie sich selbst verletzen, indem Sie Code verwenden, der nicht so verwendet werden soll

In einem ASP.NET Core-Projekt können Sie die QueryHelpers-Klasse verwenden.

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

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

Vielleicht möchten Sie sich Flurl [Offenlegung: Ich bin der Autor] ansehen , einen fließenden URL-Builder mit optionaler Companion-Bibliothek, der ihn zu einem vollständigen REST-Client erweitert.

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

Auschecken Weitere Informationen finden den Dokumenten . Das vollständige Paket ist auf NuGet verfügbar:

PM> Install-Package Flurl.Http

oder nur der eigenständige URL-Builder:

PM> Install-Package Flurl

In Anlehnung an Rostovs Beitrag können Sie from verwenden , wenn Sie keinen Verweis auf System.Webin Ihr Projekt aufnehmen möchtenFormDataCollectionSystem.Net.Http.Formatting und etwas tun , wie folgt aus :

Verwenden von 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 bot eine interessante und clevere Lösung an, und hier ist etwas, das eine andere Option sein könnte:

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

Wenn Sie es verwenden, können Sie Folgendes tun:

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

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

Oder einfach mit meiner Uri-Erweiterung

Code

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

Verwendung

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

Ergebnis

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

Die von mir entwickelte RFC 6570-URI-Vorlagenbibliothek kann diesen Vorgang ausführen. Die gesamte Codierung wird gemäß diesem RFC für Sie behandelt. Zum Zeitpunkt dieses Schreibens ist eine Beta-Version verfügbar und der einzige Grund, warum sie nicht als stabile Version 1.0 angesehen wird, ist, dass die Dokumentation meine Erwartungen nicht vollständig erfüllt (siehe Probleme Nr. 17 , Nr. 18 , Nr. 32 , Nr. 43 ).

Sie können entweder nur eine Abfragezeichenfolge erstellen:

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

Oder Sie können eine vollständige URI erstellen:

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

Da ich diese wenigen Male wiederverwenden muss, habe ich mir diese Klasse ausgedacht, die einfach dazu beiträgt, die Zusammensetzung der Abfragezeichenfolge zu abstrahieren.

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

}

Die Verwendung wird zu so etwas vereinfacht:

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

Dadurch wird die URL zurückgegeben: http://example.com/?foo=bar%3c%3e%26-baz&bar=second

Um das in der Antwort von taras.roshko beschriebene Problem der doppelten Codierung zu vermeiden und die Möglichkeit zu behalten, einfach mit Abfrageparametern zu arbeiten, können Sie uriBuilder.Uri.ParseQueryString()stattdessen verwenden HttpUtility.ParseQueryString().

Ein großer Teil der akzeptierten Antwort wurde geändert, um UriBuilder.Uri.ParseQueryString () anstelle von HttpUtility.ParseQueryString () zu verwenden:

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

Dank "Darin Dimitrov" ist dies die Erweiterungsmethode.

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

Ich konnte keine bessere Lösung finden, als eine Erweiterungsmethode zum Konvertieren eines Wörterbuchs in QueryStringFormat zu erstellen. Die von Waleed AK vorgeschlagene Lösung ist ebenfalls gut.

Folgen Sie meiner Lösung:

Erstellen Sie die Erweiterungsmethode:

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

Und sie:

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"