Append values to query string

Question

I have set of URL s similar to the ones below in a list   http   somesite com backup lol php id 1 amp server 4 amp location us http   somesite com news php article 1 amp lang en   I have managed to get the query strings using the following code   myurl   longurl Split       NameValueCollection qs   HttpUtility ParseQueryString myurl  1     foreach  string lol in qs           results will return     But it only returns the parameters like  id  server  location and so on based on the URL provided   What I need is to add   append values to the existing query strings   For example with the URL   http   somesite com backup index php action login amp attempts 1  I need to alter the values of the query string parameters   action login1  attempts 11  As you can see  I have appended  1  for each value  I need to get a set of URL s from a string with different query strings in them and add a value to each parameter at the end  amp  again add them to a list

User · Answer

The provided answers have issues with relative Url's, such as "/some/path/" This is a limitation of the Uri and UriBuilder class, which is rather hard to understand, since I don't see any reason why relative urls would be problematic when it comes to query manipulation.

Here is a workaround that works for both absolute and relative paths, written and tested in .NET 4:

(small note: this should also work in .NET 4.5, you will only have to change propInfo.GetValue(values, null) to 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; }
      ));
    }
  }

And here is a suite of unit tests to test the behavior:

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

User · Answer

I like Bjorn s answer  however the solution he s provided is misleading  as the method updates an existing parameter  rather than adding it if it doesn t exist   To make it a bit safer  I ve adapted it below   public static class UriExtensions            lt summary gt          Adds or Updates the specified parameter to the Query String           lt  summary gt           lt param name  url  gt  lt  param gt           lt param name  paramName  gt Name of the parameter to add  lt  param gt           lt param name  paramValue  gt Value for the parameter to add  lt  param gt           lt returns gt Url with added parameter  lt  returns gt      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

User · Answer

You could use the HttpUtility ParseQueryString method and an UriBuilder which provides a nice way to work with query string parameters without worrying about things like parsing  url encoding        string longurl    http   somesite com news php article 1 amp 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 amp lang en amp action login1 amp attempts 11

User · Answer

I ve wrapped Darin s answer into a nicely reusable extension method   public static class UriExtensions            lt summary gt          Adds the specified parameter to the Query String           lt  summary gt           lt param name  url  gt  lt  param gt           lt param name  paramName  gt Name of the parameter to add  lt  param gt           lt param name  paramValue  gt Value for the parameter to add  lt  param gt           lt returns gt Url with added parameter  lt  returns gt      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            I hope this helps

User · Answer

This is even more frustrating because now   net 5  MS have marked many  all  of their methods that take a string instead of a Uri as obsolete  Anyway  probably a better way to manipulate relative Uris is to give it what it wants  var requestUri   new Uri  quot x   x quot   MakeRelativeUri     new UriBuilder  quot x   x quot     Path   path  Query   query   Uri    You can use the other answers to actually build the query string

User · Answer

The end to all URL query string editing woes  After lots of toil and fiddling with the Uri class  and other solutions  here re my string extension methods to solve my problems   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   gt                        for  var i   0  i  lt  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   gt                        foreach  var key in keys                                q Remove key                                        public static string UpdateQueryString string url  Action lt NameValueCollection gt  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  gt  0         string Empty    query

User · Answer

Note you can add the Microsoft AspNetCore WebUtilities nuget package from Microsoft and then use this to append values to query string   QueryHelpers AddQueryString longurl   action    login1   QueryHelpers AddQueryString longurl  new Dictionary lt string  string gt       action    login1        attempts    11

User · Answer

The following solution works for ASP NET 5  vNext  and it uses QueryHelpers class to build a URI with parameters       public Uri GetUri                 var location    config Get  http   iberia com            Dictionary lt string  string gt  values   GetDictionaryParameters             var uri   Microsoft AspNetCore WebUtilities QueryHelpers AddQueryString location  values           return new Uri uri              private Dictionary lt string string gt  GetDictionaryParameters                 Dictionary lt string  string gt  values   new Dictionary lt string  string gt                           param1    value1                    param2    value2                   param3    value3                      return values          The result URI would have http   iberia com param1 value1 amp param2 value2 amp param3 value3

[c#] Append values to query string

Examples related to c#

Examples related to parameters

Examples related to query-string