with read querystring query parameter net from aspx asp c# parameters query-string

read - request.querystring c#



Anexar valores a la cadena de consulta (7)

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

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

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

intentos = 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.


Envolví share en un método de extensión muy reutilizable.

public static class UriExtensions { /// <summary> /// Adds the specified parameter to the Query String. /// </summary> /// <param name="url"></param> /// <param name="paramName">Name of the parameter to add.</param> /// <param name="paramValue">Value for the parameter to add.</param> /// <returns>Url with added parameter.</returns> 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!


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<string, string> values = GetDictionaryParameters(); var uri = Microsoft.AspNetCore.WebUtilities.QueryHelpers.AddQueryString(location, values); return new Uri(uri); } private Dictionary<string,string> GetDictionaryParameters() { Dictionary<string, string> values = new Dictionary<string, string> { { "param1", "value1" }, { "param2", "value2"}, { "param3", "value3"} }; return values; }

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


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{ /// <summary> /// Adds query string value to an existing url, both absolute and relative URI''s are supported. /// </summary> /// <example> /// <code> /// // returns "www.domain.com/test?param1=val1&amp;param2=val2&amp;param3=val3" /// new Uri("www.domain.com/test?param1=val1").ExtendQuery(new Dictionary&lt;string, string&gt; { { "param2", "val2" }, { "param3", "val3" } }); /// /// // returns "/test?param1=val1&amp;param2=val2&amp;param3=val3" /// new Uri("/test?param1=val1").ExtendQuery(new Dictionary&lt;string, string&gt; { { "param2", "val2" }, { "param3", "val3" } }); /// </code> /// </example> /// <param name="uri"></param> /// <param name="values"></param> /// <returns></returns> public static Uri ExtendQuery(this Uri uri, IDictionary<string, string> 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<string, string>()) { 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); } /// <summary> /// Adds query string value to an existing url, both absolute and relative URI''s are supported. /// </summary> /// <example> /// <code> /// // returns "www.domain.com/test?param1=val1&amp;param2=val2&amp;param3=val3" /// new Uri("www.domain.com/test?param1=val1").ExtendQuery(new { param2 = "val2", param3 = "val3" }); /// /// // returns "/test?param1=val1&amp;param2=val2&amp;param3=val3" /// new Uri("/test?param1=val1").ExtendQuery(new { param2 = "val2", param3 = "val3" }); /// </code> /// </example> /// <param name="uri"></param> /// <param name="values"></param> /// <returns></returns> 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<string, string>(); 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<string, string>(); 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<string, string> { { "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<string, string> { { "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<string, string> { { "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<string, string> { { "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<string, string> { { "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<string, string> { { "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))); } }


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 { /// <summary> /// Adds or Updates the specified parameter to the Query String. /// </summary> /// <param name="url"></param> /// <param name="paramName">Name of the parameter to add.</param> /// <param name="paramValue">Value for the parameter to add.</param> /// <returns>Url with added parameter.</returns> 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; } }


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 codificación 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"


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<string, string> { { "action", "login1" }, { "attempts", "11" } });