Ich möchte eine Zeichenfolge wie p1=6&p2=7&p3=8in a analysieren NameValueCollection.

Was ist die eleganteste Art, dies zu tun, wenn Sie keinen Zugriff auf das Page.RequestObjekt haben?

Hierfür gibt es ein integriertes .NET-Dienstprogramm: HttpUtility.ParseQueryString

// C#
NameValueCollection qscoll = HttpUtility.ParseQueryString(querystring);

' VB.NET
Dim qscoll As NameValueCollection = HttpUtility.ParseQueryString(querystring)

Sie können ersetzen müssen querystringmit new Uri(fullUrl).Query.

HttpUtility.ParseQueryString funktioniert so lange, wie Sie sich in einer Webanwendung befinden oder es Ihnen nichts ausmacht, eine Abhängigkeit von System.Web einzuschließen. Ein anderer Weg, dies zu tun, ist:

NameValueCollection queryParameters = new NameValueCollection();
string[] querySegments = queryString.Split('&');
foreach(string segment in querySegments)
{
   string[] parts = segment.Split('=');
   if (parts.Length > 0)
   {
      string key = parts[0].Trim(new char[] { '?', ' ' });
      string val = parts[1].Trim();

      queryParameters.Add(key, val);
   }
}

Viele der Antworten enthalten benutzerdefinierte Beispiele, da die akzeptierte Antwort von System.Web abhängt . Aus dem NuGet-Paket Microsoft.AspNet.WebApi.Client gibt es eine UriExtensions.ParseQueryString- Methode, die auch verwendet werden kann:

var uri = new Uri("https://stackoverflow.com/a/22167748?p1=6&p2=7&p3=8");
NameValueCollection query = uri.ParseQueryString();

Wenn Sie also die System.Web- Abhängigkeit vermeiden und keine eigene rollen möchten, ist dies eine gute Option.

Ich wollte die Abhängigkeit von System.Web entfernen, damit ich die Abfragezeichenfolge einer ClickOnce-Bereitstellung analysieren kann, während die Voraussetzungen auf die "Nur-Client-Framework-Teilmenge" beschränkt sind.

Ich mochte die Antwort von rp. Ich habe eine zusätzliche Logik hinzugefügt.

public static NameValueCollection ParseQueryString(string s)
    {
        NameValueCollection nvc = new NameValueCollection();

        // remove anything other than query string from url
        if(s.Contains("?"))
        {
            s = s.Substring(s.IndexOf('?') + 1);
        }

        foreach (string vp in Regex.Split(s, "&"))
        {
            string[] singlePair = Regex.Split(vp, "=");
            if (singlePair.Length == 2)
            {
                nvc.Add(singlePair[0], singlePair[1]);
            }
            else
            {
                // only one key with no value specified in query string
                nvc.Add(singlePair[0], string.Empty);
            }
        }

        return nvc;
    }

Ich brauchte eine Funktion, die etwas vielseitiger ist als die, die bereits bei der Arbeit mit OLSC-Abfragen bereitgestellt wurde.

• Werte können mehrere Gleichheitszeichen enthalten
• Dekodieren Sie codierte Zeichen in Name und Wert
• Kann auf Client Framework ausgeführt werden
• Kann auf Mobile Framework ausgeführt werden.

Hier ist meine Lösung:

Public Shared Function ParseQueryString(ByVal uri As Uri) As System.Collections.Specialized.NameValueCollection
    Dim result = New System.Collections.Specialized.NameValueCollection(4)
    Dim query = uri.Query
    If Not String.IsNullOrEmpty(query) Then
        Dim pairs = query.Substring(1).Split("&"c)
        For Each pair In pairs
            Dim parts = pair.Split({"="c}, 2)

            Dim name = System.Uri.UnescapeDataString(parts(0))
            Dim value = If(parts.Length = 1, String.Empty,
                System.Uri.UnescapeDataString(parts(1)))

            result.Add(name, value)
        Next
    End If
    Return result
End Function

Es ist vielleicht keine schlechte Idee, auch das in Angriff <Extension()>zu nehmen, um Uri selbst die Fähigkeit zu verleihen.

Um dies ohne System.Web, ohne selbst zu schreiben und ohne zusätzliche NuGet-Pakete zu tun :

1. Fügen Sie einen Verweis auf hinzu System.Net.Http.Formatting
2. Hinzufügen using System.Net.Http;

3. Verwenden Sie diesen Code:

   new Uri(uri).ParseQueryString()

https://msdn.microsoft.com/en-us/library/system.net.http.uriextensions(v=vs.118).aspx

Wenn Sie die Abhängigkeit von System.Web vermeiden möchten, die für die Verwendung von HttpUtility.ParseQueryString erforderlich ist , können Sie die UriErweiterungsmethode ParseQueryStringin verwenden System.Net.Http.

Stellen Sie sicher, dass Sie System.Net.HttpIhrem Projekt eine Referenz hinzufügen (falls Sie dies noch nicht getan haben) .

Beachten Sie, dass Sie den Antworttext in einen gültigen konvertieren müssen, Uridamit ParseQueryString(in System.Net.Http) funktioniert.

string body = "value1=randomvalue1&value2=randomValue2";

// "http://localhost/query?" is added to the string "body" in order to create a valid Uri.
string urlBody = "http://localhost/query?" + body;
NameValueCollection coll = new Uri(urlBody).ParseQueryString();

    private void button1_Click( object sender, EventArgs e )
    {
        string s = @"p1=6&p2=7&p3=8";
        NameValueCollection nvc = new NameValueCollection();

        foreach ( string vp in Regex.Split( s, "&" ) )
        {
            string[] singlePair = Regex.Split( vp, "=" );
            if ( singlePair.Length == 2 )
            {
                nvc.Add( singlePair[ 0 ], singlePair[ 1 ] );    
            }    
        }
    }

Ich habe gerade festgestellt, dass der Web-API-Client eine ParseQueryStringErweiterungsmethode hat, die auf a funktioniert Uriund Folgendes zurückgibt HttpValueCollection:

var parameters = uri.ParseQueryString();
string foo = parameters["foo"];

Greifen Sie einfach auf Request.QueryString zu. AllKeys, das als weitere Antwort erwähnt wird, bietet Ihnen nur eine Reihe von Schlüsseln.

HttpUtility.ParseQueryString(Request.Url.Query)return is HttpValueCollection(interne Klasse). Es erbt von NameValueCollection.

    var qs = HttpUtility.ParseQueryString(Request.Url.Query);
    qs.Remove("foo"); 

    string url = "~/Default.aspx"; 
    if (qs.Count > 0)
       url = url + "?" + qs.ToString();

    Response.Redirect(url); 

Wenn Sie die System.Web-Abhängigkeit nicht möchten, fügen Sie einfach diesen Quellcode aus der HttpUtility-Klasse ein.

Ich habe das gerade aus dem Quellcode von Mono zusammengestellt . Es enthält die HttpUtility und alle ihre Abhängigkeiten (wie IHtmlString, Helpers, HttpEncoder, HttpQSCollection).

Dann verwenden HttpUtility.ParseQueryString.

https://gist.github.com/bjorn-ali-goransson/b04a7c44808bb2de8cca3fc9a3762f9c

Da jeder seine Lösung einzufügen scheint .. hier ist meine :-) Ich brauchte diese aus einer Klassenbibliothek heraus, ohne System.WebID-Parameter von gespeicherten Hyperlinks abzurufen.

Ich dachte, ich würde teilen, weil ich diese Lösung schneller finde und besser aussehe.

public static class Statics
    public static Dictionary<string, string> QueryParse(string url)
    {
        Dictionary<string, string> qDict = new Dictionary<string, string>();
        foreach (string qPair in url.Substring(url.IndexOf('?') + 1).Split('&'))
        {
            string[] qVal = qPair.Split('=');
            qDict.Add(qVal[0], Uri.UnescapeDataString(qVal[1]));
        }
        return qDict;
    }

    public static string QueryGet(string url, string param)
    {
        var qDict = QueryParse(url);
        return qDict[param];
    }
}

Verwendung:

Statics.QueryGet(url, "id")

Klicken Sie auf Request.QueryString.Keys, um eine NameValueCollection aller Abfragezeichenfolgenparameter zu erhalten.

Um alle Querystring-Werte zu erhalten, versuchen Sie Folgendes:

    Dim qscoll As NameValueCollection = HttpUtility.ParseQueryString(querystring)

Dim sb As New StringBuilder("<br />")
For Each s As String In qscoll.AllKeys

  Response.Write(s & " - " & qscoll(s) & "<br />")

Next s

        var q = Request.QueryString;
        NameValueCollection qscoll = HttpUtility.ParseQueryString(q.ToString());

let search = window.location.search;

console.log(search);

let qString = search.substring(1);

while(qString.indexOf("+") !== -1)

   qString  = qString.replace("+", "");

let qArray = qString.split("&");

let values = [];

for(let i = 0; i < qArray.length; i++){
   let pos = qArray[i].search("=");
   let keyVal = qArray[i].substring(0, pos);
   let dataVal = qArray[i].substring(pos + 1);
   dataVal = decodeURIComponent(dataVal);
   values[keyVal] = dataVal;
}

Ich übersetze in VB in die C # -Version von Josh-Brown

private System.Collections.Specialized.NameValueCollection ParseQueryString(Uri uri)
{
    var result = new System.Collections.Specialized.NameValueCollection(4);
    var query = uri.Query;
    if (!String.IsNullOrEmpty(query))
    {
        var pairs = query.Substring(1).Split("&".ToCharArray());
        foreach (var pair in pairs)
        {
            var parts = pair.Split("=".ToCharArray(), 2);
            var name = System.Uri.UnescapeDataString(parts[0]);
            var value = (parts.Length == 1) ? String.Empty : System.Uri.UnescapeDataString(parts[1]);
            result.Add(name, value);
        }
    }
    return result;
}

Dies ist mein Code, ich denke, es ist sehr nützlich:

public String GetQueryString(string ItemToRemoveOrInsert = null, string InsertValue = null )
{
    System.Collections.Specialized.NameValueCollection filtered = new System.Collections.Specialized.NameValueCollection(Request.QueryString);
    if (ItemToRemoveOrInsert != null)
    {
        filtered.Remove(ItemToRemoveOrInsert);
        if (!string.IsNullOrWhiteSpace(InsertValue))
        {
            filtered.Add(ItemToRemoveOrInsert, InsertValue);
        }
    }

    string StrQr = string.Join("&", filtered.AllKeys.Select(key => key + "=" + filtered[key]).ToArray());
    if (!string.IsNullOrWhiteSpace(StrQr)){
        StrQr="?" + StrQr;
    }

    return StrQr;
}