Anexar valores a la cadena de consulta

Tengo un conjunto de URL similar a las siguientes en una lista

  • http://somesite.com/backup/lol.php?id=1&server=4&location=us
  • http://somesite.com/news.php?article=1&lang=en

Logré obtener las cadenas de consulta utilizando el siguiente código:

myurl = longurl.Split('?'); NameValueCollection qs = HttpUtility.ParseQueryString(myurl [1]); foreach (string lol in qs) { // results will return } 

Pero solo devuelve los parámetros como id , servidor , ubicación , etc. según la URL proporcionada.

Lo que necesito es agregar / agregar valores a las cadenas de consulta existentes.

Por ejemplo, con la URL:

http://somesite.com/backup/index.php?action=login&attempts=1

Necesito modificar los valores de los parámetros de cadena de consulta:

acción = iniciar sesión1

bashs = 11

Como puede ver, he agregado “1” para cada valor. Necesito obtener un conjunto de URL de una cadena con diferentes cadenas de consulta en ellas y agregar un valor a cada parámetro al final y agregarlas nuevamente a una lista.

Podría usar el método HttpUtility.ParseQueryString y un UriBuilder que proporciona una buena manera de trabajar con los parámetros de cadena de consulta sin preocuparse por cosas como el análisis sintáctico, la encoding de URL, …:

 string longurl = "http://somesite.com/news.php?article=1&lang=en"; var uriBuilder = new UriBuilder(longurl); var query = HttpUtility.ParseQueryString(uriBuilder.Query); query["action"] = "login1"; query["attempts"] = "11"; uriBuilder.Query = query.ToString(); longurl = uriBuilder.ToString(); // "http://somesite.com:80/news.php?article=1&lang=en&action=login1&attempts=11" 

Envolví la respuesta de Darin en un método de extensión muy reutilizable.

 public static class UriExtensions { ///  /// Adds the specified parameter to the Query String. ///  ///  /// Name of the parameter to add. /// Value for the parameter to add. /// Url with added parameter. public static Uri AddParameter(this Uri url, string paramName, string paramValue) { var uriBuilder = new UriBuilder(url); var query = HttpUtility.ParseQueryString(uriBuilder.Query); query[paramName] = paramValue; uriBuilder.Query = query.ToString(); return uriBuilder.Uri; } } 

¡Espero que esto ayude!

Las respuestas proporcionadas tienen problemas con las URL relativas, como “/ some / path /” Esta es una limitación de la clase Uri y UriBuilder, que es bastante difícil de entender, ya que no veo ninguna razón por la cual las URL relativas serían problemáticas. cuando se trata de manipulación de consultas.

Aquí hay una solución alternativa que funciona tanto para rutas absolutas como relativas, escrita y probada en .NET 4:

(Nota pequeña: esto también debería funcionar en .NET 4.5, solo tendrá que cambiar propInfo.GetValue(values, null) a propInfo.GetValue(values) )

  public static class UriExtensions{ ///  /// Adds query string value to an existing url, both absolute and relative URI's are supported. ///  ///  ///  /// // returns "www.domain.com/test?param1=val1&param2=val2&param3=val3" /// new Uri("www.domain.com/test?param1=val1").ExtendQuery(new Dictionary<string, string> { { "param2", "val2" }, { "param3", "val3" } }); /// /// // returns "/test?param1=val1&param2=val2&param3=val3" /// new Uri("/test?param1=val1").ExtendQuery(new Dictionary<string, string> { { "param2", "val2" }, { "param3", "val3" } }); ///  ///  ///  ///  ///  public static Uri ExtendQuery(this Uri uri, IDictionary values) { var baseUrl = uri.ToString(); var queryString = string.Empty; if (baseUrl.Contains("?")) { var urlSplit = baseUrl.Split('?'); baseUrl = urlSplit[0]; queryString = urlSplit.Length > 1 ? urlSplit[1] : string.Empty; } NameValueCollection queryCollection = HttpUtility.ParseQueryString(queryString); foreach (var kvp in values ?? new Dictionary()) { queryCollection[kvp.Key] = kvp.Value; } var uriKind = uri.IsAbsoluteUri ? UriKind.Absolute : UriKind.Relative; return queryCollection.Count == 0 ? new Uri(baseUrl, uriKind) : new Uri(string.Format("{0}?{1}", baseUrl, queryCollection), uriKind); } ///  /// Adds query string value to an existing url, both absolute and relative URI's are supported. ///  ///  ///  /// // returns "www.domain.com/test?param1=val1&param2=val2&param3=val3" /// new Uri("www.domain.com/test?param1=val1").ExtendQuery(new { param2 = "val2", param3 = "val3" }); /// /// // returns "/test?param1=val1&param2=val2&param3=val3" /// new Uri("/test?param1=val1").ExtendQuery(new { param2 = "val2", param3 = "val3" }); ///  ///  ///  ///  ///  public static Uri ExtendQuery(this Uri uri, object values) { return ExtendQuery(uri, values.GetType().GetProperties().ToDictionary ( propInfo => propInfo.Name, propInfo => { var value = propInfo.GetValue(values, null); return value != null ? value.ToString() : null; } )); } } 

Y aquí hay un conjunto de pruebas unitarias para probar el comportamiento:

  [TestFixture] public class UriExtensionsTests { [Test] public void Add_to_query_string_dictionary_when_url_contains_no_query_string_and_values_is_empty_should_return_url_without_changing_it() { Uri url = new Uri("http://www.domain.com/test"); var values = new Dictionary(); var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("http://www.domain.com/test"))); } [Test] public void Add_to_query_string_dictionary_when_url_contains_hash_and_query_string_values_are_empty_should_return_url_without_changing_it() { Uri url = new Uri("http://www.domain.com/test#div"); var values = new Dictionary(); var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("http://www.domain.com/test#div"))); } [Test] public void Add_to_query_string_dictionary_when_url_contains_no_query_string_should_add_values() { Uri url = new Uri("http://www.domain.com/test"); var values = new Dictionary { { "param1", "val1" }, { "param2", "val2" } }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("http://www.domain.com/test?param1=val1&param2=val2"))); } [Test] public void Add_to_query_string_dictionary_when_url_contains_hash_and_no_query_string_should_add_values() { Uri url = new Uri("http://www.domain.com/test#div"); var values = new Dictionary { { "param1", "val1" }, { "param2", "val2" } }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("http://www.domain.com/test#div?param1=val1&param2=val2"))); } [Test] public void Add_to_query_string_dictionary_when_url_contains_query_string_should_add_values_and_keep_original_query_string() { Uri url = new Uri("http://www.domain.com/test?param1=val1"); var values = new Dictionary { { "param2", "val2" } }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("http://www.domain.com/test?param1=val1&param2=val2"))); } [Test] public void Add_to_query_string_dictionary_when_url_is_relative_contains_no_query_string_should_add_values() { Uri url = new Uri("/test", UriKind.Relative); var values = new Dictionary { { "param1", "val1" }, { "param2", "val2" } }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("/test?param1=val1&param2=val2", UriKind.Relative))); } [Test] public void Add_to_query_string_dictionary_when_url_is_relative_and_contains_query_string_should_add_values_and_keep_original_query_string() { Uri url = new Uri("/test?param1=val1", UriKind.Relative); var values = new Dictionary { { "param2", "val2" } }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("/test?param1=val1&param2=val2", UriKind.Relative))); } [Test] public void Add_to_query_string_dictionary_when_url_is_relative_and_contains_query_string_with_existing_value_should_add_new_values_and_update_existing_ones() { Uri url = new Uri("/test?param1=val1", UriKind.Relative); var values = new Dictionary { { "param1", "new-value" }, { "param2", "val2" } }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("/test?param1=new-value&param2=val2", UriKind.Relative))); } [Test] public void Add_to_query_string_object_when_url_contains_no_query_string_should_add_values() { Uri url = new Uri("http://www.domain.com/test"); var values = new { param1 = "val1", param2 = "val2" }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("http://www.domain.com/test?param1=val1&param2=val2"))); } [Test] public void Add_to_query_string_object_when_url_contains_query_string_should_add_values_and_keep_original_query_string() { Uri url = new Uri("http://www.domain.com/test?param1=val1"); var values = new { param2 = "val2" }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("http://www.domain.com/test?param1=val1&param2=val2"))); } [Test] public void Add_to_query_string_object_when_url_is_relative_contains_no_query_string_should_add_values() { Uri url = new Uri("/test", UriKind.Relative); var values = new { param1 = "val1", param2 = "val2" }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("/test?param1=val1&param2=val2", UriKind.Relative))); } [Test] public void Add_to_query_string_object_when_url_is_relative_and_contains_query_string_should_add_values_and_keep_original_query_string() { Uri url = new Uri("/test?param1=val1", UriKind.Relative); var values = new { param2 = "val2" }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("/test?param1=val1&param2=val2", UriKind.Relative))); } [Test] public void Add_to_query_string_object_when_url_is_relative_and_contains_query_string_with_existing_value_should_add_new_values_and_update_existing_ones() { Uri url = new Uri("/test?param1=val1", UriKind.Relative); var values = new { param1 = "new-value", param2 = "val2" }; var result = url.ExtendQuery(values); Assert.That(result, Is.EqualTo(new Uri("/test?param1=new-value&param2=val2", UriKind.Relative))); } } 

La siguiente solución funciona para ASP.NET 5 (vNext) y utiliza la clase QueryHelpers para construir un URI con parámetros.

  public Uri GetUri() { var location = _config.Get("http://iberia.com"); Dictionary values = GetDictionaryParameters(); var uri = Microsoft.AspNetCore.WebUtilities.QueryHelpers.AddQueryString(location, values); return new Uri(uri); } private Dictionary GetDictionaryParameters() { Dictionary values = new Dictionary { { "param1", "value1" }, { "param2", "value2"}, { "param3", "value3"} }; return values; } 

El resultado URI tendría http://iberia.com?param1=value1&param2=value2&param3=value3

Tenga en cuenta que puede agregar el paquete nuget Microsoft.AspNetCore.WebUtilities de Microsoft y luego usar esto para agregar valores a la cadena de consulta:

 QueryHelpers.AddQueryString(longurl, "action", "login1") QueryHelpers.AddQueryString(longurl, new Dictionary { { "action", "login1" }, { "attempts", "11" } }); 

El final de todos los problemas de edición de cadenas de consulta de URL

Después de muchos trabajos y manipulaciones con la clase Uri, y otras soluciones, aquí están mis métodos de extensión de cadenas para resolver mis problemas.

 using System; using System.Collections.Specialized; using System.Linq; using System.Web; public static class StringExtensions { public static string AddToQueryString(this string url, params object[] keysAndValues) { return UpdateQueryString(url, q => { for (var i = 0; i < keysAndValues.Length; i += 2) { q.Set(keysAndValues[i].ToString(), keysAndValues[i + 1].ToString()); } }); } public static string RemoveFromQueryString(this string url, params string[] keys) { return UpdateQueryString(url, q => { foreach (var key in keys) { q.Remove(key); } }); } public static string UpdateQueryString(string url, Action func) { var urlWithoutQueryString = url.Contains('?') ? url.Substring(0, url.IndexOf('?')) : url; var queryString = url.Contains('?') ? url.Substring(url.IndexOf('?')) : null; var query = HttpUtility.ParseQueryString(queryString ?? string.Empty); func(query); return urlWithoutQueryString + (query.Count > 0 ? "?" : string.Empty) + query; } } 

Me gusta la respuesta de Bjorn, sin embargo, la solución que ha proporcionado es engañosa, ya que el método actualiza un parámetro existente, en lugar de agregarlo si no existe. Para hacerlo un poco más seguro, lo he adaptado a continuación.

 public static class UriExtensions { ///  /// Adds or Updates the specified parameter to the Query String. ///  ///  /// Name of the parameter to add. /// Value for the parameter to add. /// Url with added parameter. public static Uri AddOrUpdateParameter(this Uri url, string paramName, string paramValue) { var uriBuilder = new UriBuilder(url); var query = HttpUtility.ParseQueryString(uriBuilder.Query); if (query.AllKeys.Contains(paramName)) { query[paramName] = paramValue; } else { query.Add(paramName, paramValue); } uriBuilder.Query = query.ToString(); return uriBuilder.Uri; } } 

Mi enfoque es muy simple, para principiantes:

 // --> Prototype : https://ctrader.guru/?id=1#reload public static string AddGetParamToUrl(string url, string pname, string pvalue) { pvalue = Uri.EscapeDataString(pvalue); if (url.IndexOf("?") > -1) { url = url.Replace("?", string.Format("?{0}={1}&", pname, pvalue)); } else if (url.IndexOf("#") > -1) { url = url.Replace("#", string.Format("?{0}={1}#", pname, pvalue)); } else { url = string.Format("{0}?{1}={2}", url, pname, pvalue); } return url; }