Crear cadena de consulta para System.Net.HttpClient get

Si deseo enviar una solicitud de obtención de http utilizando System.Net.HttpClient parece que no hay una API para agregar parámetros, ¿es esto correcto?

¿Hay alguna api simple disponible para construir la cadena de consulta que no implique construir una colección de valores de nombre y url que los codifique y luego finalmente los concatene? Esperaba usar algo como la api de RestSharp (es decir, AddParameter (..))

Si deseo enviar una solicitud de obtención de http utilizando System.Net.HttpClient parece que no hay una API para agregar parámetros, ¿es esto correcto?

Si.

¿Hay alguna api simple disponible para construir la cadena de consulta que no implique construir una colección de valores de nombre y url que los codifique y luego finalmente los concatene?

Por supuesto:

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

te dará el resultado esperado:

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

También puede encontrar UriBuilderútil la clase:

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

te dará el resultado esperado:

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

que podría alimentar con más seguridad su HttpClient.GetAsyncmétodo.

Para aquellos que no quieren incluir System.Weben los proyectos que aún no lo utilizan, se puede utilizar FormUrlEncodedContentdesde System.Net.Httpy hacer algo como lo siguiente:

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

versión del diccionario

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: no use la versión aceptada ya que está completamente rota en relación con el manejo de caracteres Unicode, y nunca use API interna

De hecho, he encontrado un extraño problema de doble codificación con la solución aceptada:

Entonces, si se trata de caracteres que necesitan ser codificados, la solución aceptada conduce a una doble codificación:

• los parámetros de consulta se codifican automáticamente mediante el uso de NameValueCollectionindexador ( y esto utiliza UrlEncodeUnicode, no se espera regularmente UrlEncode(!) )
• Luego, cuando lo llama uriBuilder.Uri, crea un nuevo Uriconstructor usando que codifica una vez más (codificación de URL normal)
• Eso no se puede evitar haciendouriBuilder.ToString() (a pesar de que esto devuelve correcto Uriqué IMO es al menos inconsistencia, tal vez un error, pero esa es otra pregunta) y luego usando el HttpClientmétodo de aceptación de cadena: el cliente aún crea a Uripartir de su cadena pasada de esta manera:new Uri(uri, UriKind.RelativeOrAbsolute)

Pequeño pero completo 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!

Salida:

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

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

Como puede ver, no importa si hace uribuilder.ToString()+ httpClient.GetStringAsync(string)o uriBuilder.Uri+ httpClient.GetStringAsync(Uri), termina enviando un parámetro codificado doble

Ejemplo fijo podría ser:

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

Pero esto usa un constructor obsoleto Uri

PS en mi último .NET en Windows Server, el Uriconstructor con el comentario de bool doc dice "obsoleto, dontEscape siempre es falso", pero en realidad funciona como se espera (se escapa)

Entonces parece otro error ...

E incluso esto es simplemente incorrecto: envía UrlEncodedUnicode al servidor, no solo UrlEncoded lo que el servidor espera

Actualización: una cosa más es que NameValueCollection realmente hace UrlEncodeUnicode, que se supone que ya no se debe usar y es incompatible con url.encode / decode (¿Ver NameValueCollection to URL Query? ).

Entonces, la conclusión es: nunca use este truco,NameValueCollection query = HttpUtility.ParseQueryString(builder.Query); ya que alterará sus parámetros de consulta Unicode. Simplemente construya la consulta manualmente y asígnele lo UriBuilder.Queryque hará la codificación necesaria y luego use Uri UriBuilder.Uri.

Primer ejemplo de lastimarse a sí mismo usando un código que no se debe usar de esta manera

En un proyecto ASP.NET Core puede usar la clase QueryHelpers.

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

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

Es posible que desee consultar Flurl [divulgación: soy el autor], un creador de URL fluido con lib complementario opcional que lo extiende en un cliente REST completo.

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

Echa un vistazo a los documentos para más detalles. El paquete completo está disponible en NuGet:

PM> Install-Package Flurl.Http

o solo el creador de URL independiente:

PM> Install-Package Flurl

A lo largo de las mismas líneas que el post de Rostov, si no se desea incluir una referencia a System.Websu proyecto, puede utilizar FormDataCollectiondesde System.Net.Http.Formattingy hacer algo como lo siguiente:

Utilizando 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 ofreció una solución interesante e inteligente, y aquí hay algo que puede ser otra opción:

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

y así, al usarlo, puede hacer esto:

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

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

O simplemente usando mi extensión Uri

Código

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

Uso

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

Resultado

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

La biblioteca de plantillas RFC 6570 URI que estoy desarrollando es capaz de realizar esta operación. Toda la codificación se maneja para usted de acuerdo con ese RFC. En el momento de escribir este artículo, hay disponible una versión beta y la única razón por la que no se considera una versión 1.0 estable es que la documentación no cumple completamente mis expectativas (consulte los problemas # 17 , # 18 , # 32 , # 43 ).

Puede construir una cadena de consulta solo:

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

O podrías construir un URI completo:

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

Dado que tengo que reutilizar estas pocas veces, se me ocurrió esta clase que simplemente ayuda a abstraer cómo se compone la cadena de consulta.

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

}

El uso se simplificará a algo como esto:

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

eso devolverá la uri: http://example.com/?foo=bar%3c%3e%26-baz&bar=second

Para evitar el problema de doble codificación descrito en la respuesta de taras.roshko y mantener la posibilidad de trabajar fácilmente con parámetros de consulta, puede usar en uriBuilder.Uri.ParseQueryString()lugar de HttpUtility.ParseQueryString().

Buena parte de la respuesta aceptada, modificada para usar UriBuilder.Uri.ParseQueryString () en lugar de 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();

Gracias a "Darin Dimitrov", este es el método de extensión.

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

No pude encontrar una mejor solución que crear un método de extensión para convertir un Diccionario a QueryStringFormat. La solución propuesta por Waleed AK también es buena.

Sigue mi solución:

Crea el método de extensión:

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

Y ellos:

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"