मान को क्वेरी स्ट्रिंग में जोड़ें

Question

मैंने एक सूची में नीचे दिए गए URL के समान सेट किया है

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

मैं निम्नलिखित कोड का उपयोग करके क्वेरी स्ट्रिंग प्राप्त करने में कामयाब रहा हूं:

myurl = longurl.Split('?');
NameValueCollection qs = HttpUtility.ParseQueryString(myurl [1]);

foreach (string lol in qs)
{
    // results will return
}

लेकिन यह केवल प्रदान किए गए URL के आधार पर आईडी , सर्वर , स्थान और जैसे मापदंडों को लौटाता है ।

मुझे मौजूदा क्वेरी स्ट्रिंग्स में मान जोड़ने / जोड़ने की आवश्यकता है।

URL के साथ उदाहरण के लिए:

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

मुझे क्वेरी स्ट्रिंग मापदंडों के मूल्यों को बदलने की आवश्यकता है:

कार्रवाई = login1

प्रयास = 11

जैसा कि आप देख सकते हैं, मैंने प्रत्येक मूल्य के लिए "1" जोड़ा है। मुझे उनमें से अलग-अलग क्वेरी स्ट्रिंग के साथ स्ट्रिंग से URL का एक सेट प्राप्त करने की आवश्यकता है और अंत में प्रत्येक पैरामीटर के लिए एक मूल्य जोड़ें और फिर से उन्हें एक सूची में जोड़ें।

Answer 1

आप इस HttpUtility.ParseQueryStringपद्धति का उपयोग कर सकते हैं और UriBuilderजो पार्सिंग, यूआरएल एन्कोडिंग, ... जैसी चीजों की चिंता किए बिना क्वेरी स्ट्रिंग मापदंडों के साथ काम करने का एक अच्छा तरीका प्रदान करता है: ...

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"

Comments

जैसा कि आप मेरे उदाहरण से देख सकते हैं कि आप मापदंडों के लिए चर नामों का उपयोग कर सकते हैं। और ठीक यही वह करता है: यह मौजूदा url के लिए 2 मापदंडों को जोड़ता है जो मैंने यहां हार्डकोड किया है, लेकिन वे पूरी तरह से गतिशील हो सकते हैं।

— डारिन दिमित्रोव

क्या हमें HttpUtility.UrlEncode()पैरामीटर मान निर्दिष्ट करते समय उपयोग नहीं करना चाहिए ?

— यूजरक्रन्ट

@UserControl, नहीं, HttpUtility.ParseQueryStringविधि एक विशेष NameValueCollection कार्यान्वयन देता है जो पहले से ही पर्दे के पीछे इसे संभालता है जब आप एक मूल्य निर्धारित करते हैं।

— डारिन दिमित्रोव

Bummer कि यह System.Web पर निर्भरता

— रखता है

यह ध्यान देने योग्य है कि यह दृष्टिकोण अंतर्राष्ट्रीयकरण के साथ मुद्दों का कारण बन सकता है क्योंकि विशेष वर्ण क्वेरी में अपने यूनिकोड समकक्षों में परिवर्तित हो जाएंगे। स्ट्रिंग () विधि।

— तेजोमेनिया

Answer 2

मैंने डैरिन के उत्तर को एक अच्छी तरह से पुन: प्रयोज्य विस्तार विधि में लपेट दिया है ।

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

आशा है कि ये आपकी मदद करेगा!

Answer 3

प्रदान किए गए उत्तरों में रिश्तेदार Url के साथ समस्याएँ हैं, जैसे "/ / कुछ / पथ /" यह Uri और UriBuilder वर्ग की एक सीमा है, जिसे समझना मुश्किल है, क्योंकि मुझे कोई कारण नहीं दिखता कि रिश्तेदार url समस्याग्रस्त क्यों होंगे? जब क्वेरी हेरफेर की बात आती है।

यहाँ एक वर्कअराउंड है जो .NET 4 में लिखित और परीक्षण किए गए निरपेक्ष और सापेक्ष पथ दोनों के लिए काम करता है:

(छोटा नोट: यह भी .NET 4.5 में काम करना चाहिए, आपको केवल बदलना propInfo.GetValue(values, null)होगा 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; }
      ));
    }
  }

और यहां व्यवहार का परीक्षण करने के लिए यूनिट परीक्षणों का एक सूट है:

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

Comments

दुर्भाग्य से यह समाधान क्लाउड .NET का उपयोग करके ASP.NET 5 के लिए काम नहीं करता है क्योंकि HttpUtility उपलब्ध नहीं है। लेकिन यह एक महान समाधान है अन्यथा। देखें stackoverflow.com/questions/29992848/...

— diegosasw

"Add_to_query_string_dEDIA_when_url_contains_hash_and_no_query_string_should_add_values" को परीक्षण करना चाहिए कि URL domain.com/test.param1=val1¶m2=val2#div

— gliljas

कृपया जाँच लें, कि कहीं आप नॉन-अन-एस्केपिंग इफेक्ट्स uri.AbsoluteUriके uri.ToString()कारण बेहतर उपयोग नहीं कर रहे हैं ।

— निको

जोड़: uri.AbsoluteUriफेंकता है, अगर यूरी निरपेक्ष नहीं है!

— निको

Answer 4

नोट आप Microsoft.AspNetCore.WebUtilitiesMicrosoft से नगेट पैकेज जोड़ सकते हैं और फिर क्वेरी स्ट्रिंग में मानों को जोड़ने के लिए इसका उपयोग कर सकते हैं :

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

Comments

ASP.NET कोर 3.0 वेबउपयोगिताओं के रूप में अब ASP.NET SDK का हिस्सा है, इसलिए कोई नगेट पैकेज की आवश्यकता नहीं है।

— user1069816

इसके साथ समस्या AddQueryStringयह है कि यह हमेशा जोड़ देगा, अगर पहले से ही कुंजी है, तो यह अपडेट नहीं होगा, लेकिन डुप्लिकेट कुंजी बनाएं, खराब है

— वेंकोवस्की

Answer 5

निम्न समाधान ASP.NET 5 (vNext) के लिए काम करता है और यह पैरामीटर के साथ URI का निर्माण करने के लिए QueryHelpers वर्ग का उपयोग करता है।

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

परिणाम URI होगा http://iberia.com?param1=value1&param2=value2&param3=value3

Comments

क्वेरी कुंजियों और मूल्यों के लिए स्टोर के रूप में एक डिक्शनरी का उपयोग करने में एकमात्र समस्या यह है कि क्वेरी स्ट्रिंग्स में विभिन्न मानों के साथ डुप्लिकेट कुंजियाँ हो सकती हैं। मेरा मानना ​​है कि ASP.NET साइट के लिए अनुरोध उस एक कुंजी के लिए मानों की एक सरणी के रूप में पार्स करता है।

— सेठ

Answer 6

सभी URL क्वेरी स्ट्रिंग संपादन मुसीबतों का अंत

उरी वर्ग और अन्य समाधानों के साथ बहुत सारे टॉयलेट और फ़िडलिंग के बाद, यहां मेरी समस्याओं को हल करने के लिए मेरे स्ट्रिंग एक्सटेंशन तरीके हैं।

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

Comments

मैं stringइस तरह से Uriउस उद्देश्य के लिए पहले से मौजूद वर्ग को देखते हुए लोगों को यूआरएल का प्रतिनिधित्व करने के लिए कच्चे एस का उपयोग करने से हतोत्साहित करता हूं । या तो उस का उपयोग करें, या एक ब्रांड नई अमूर्तता बनाएँ अगर सुविधाएँ गायब हैं।

— जुलीगॉन

Answer 7

मुझे ब्योर्न का जवाब पसंद है, हालांकि वह जो समाधान प्रदान करता है वह भ्रामक है, क्योंकि विधि मौजूदा पैरामीटर को अपडेट करती है, बजाय इसे जोड़ने के अगर यह मौजूद नहीं है .. तो इसे थोड़ा सुरक्षित बनाने के लिए, मैंने इसे नीचे अनुकूलित किया है।

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

Comments

मैंने वास्तव में कोड का एक सीमांत संपादन किया, मैंने इसे प्रदान नहीं किया (ओपी ने किया ...) हालांकि क्या अंतर होगा?

यदि / अन्यथा आवश्यक नहीं है, तो बस query[paramName] = paramValue;सभी मामलों में करें। यह मौजूद है, यह विकट हो जाएगा। यदि यह मौजूद नहीं है, तो कुंजी wil बनाया जाएगा।

— रिचर्ड

Answer 8

शुरुआती लोगों के लिए मेरा दृष्टिकोण बहुत सरल है:

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

    }