Obtenir les paramètres d'URL d'une chaîne dans .NET

J'ai une chaîne en .NET qui est en fait une URL. Je veux un moyen simple d'obtenir la valeur d'un paramètre particulier.

Normalement, j'utiliserais simplement Request.Params["theThingIWant"], mais cette chaîne ne provient pas de la demande. Je peux créer un nouvel Uriarticle comme ceci:

Uri myUri = new Uri(TheStringUrlIWantMyValueFrom);

Je peux utiliser myUri.Querypour obtenir la chaîne de requête ... mais ensuite, je dois apparemment trouver un moyen regexy de le diviser.

Suis-je en train de manquer quelque chose d'évident, ou n'y a-t-il pas de moyen intégré pour faire cela à court de créer une expression régulière d'une sorte, etc.?

Utilisez une ParseQueryStringméthode statique de System.Web.HttpUtilityclasse qui renvoie NameValueCollection.

Uri myUri = new Uri("http://www.example.com?param1=good&param2=bad");
string param1 = HttpUtility.ParseQueryString(myUri.Query).Get("param1");

Consultez la documentation à http://msdn.microsoft.com/en-us/library/ms150046.aspx

C'est probablement ce que tu veux

var uri = new Uri("http://domain.test/Default.aspx?var1=true&var2=test&var3=3");
var query = HttpUtility.ParseQueryString(uri.Query);

var var2 = query.Get("var2");

Voici une autre alternative si, pour une raison quelconque, vous ne pouvez pas ou ne voulez pas utiliser HttpUtility.ParseQueryString().

Ceci est construit pour être quelque peu tolérant aux chaînes de requête "mal formées", c'est-à-dire qu'il http://test/test.html?empty=devient un paramètre avec une valeur vide. L'appelant peut vérifier les paramètres si nécessaire.

public static class UriHelper
{
    public static Dictionary<string, string> DecodeQueryParameters(this Uri uri)
    {
        if (uri == null)
            throw new ArgumentNullException("uri");

        if (uri.Query.Length == 0)
            return new Dictionary<string, string>();

        return uri.Query.TrimStart('?')
                        .Split(new[] { '&', ';' }, StringSplitOptions.RemoveEmptyEntries)
                        .Select(parameter => parameter.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries))
                        .GroupBy(parts => parts[0],
                                 parts => parts.Length > 2 ? string.Join("=", parts, 1, parts.Length - 1) : (parts.Length > 1 ? parts[1] : ""))
                        .ToDictionary(grouping => grouping.Key,
                                      grouping => string.Join(",", grouping));
    }
}

Tester

[TestClass]
public class UriHelperTest
{
    [TestMethod]
    public void DecodeQueryParameters()
    {
        DecodeQueryParametersTest("http://test/test.html", new Dictionary<string, string>());
        DecodeQueryParametersTest("http://test/test.html?", new Dictionary<string, string>());
        DecodeQueryParametersTest("http://test/test.html?key=bla/blub.xml", new Dictionary<string, string> { { "key", "bla/blub.xml" } });
        DecodeQueryParametersTest("http://test/test.html?eins=1&zwei=2", new Dictionary<string, string> { { "eins", "1" }, { "zwei", "2" } });
        DecodeQueryParametersTest("http://test/test.html?empty", new Dictionary<string, string> { { "empty", "" } });
        DecodeQueryParametersTest("http://test/test.html?empty=", new Dictionary<string, string> { { "empty", "" } });
        DecodeQueryParametersTest("http://test/test.html?key=1&", new Dictionary<string, string> { { "key", "1" } });
        DecodeQueryParametersTest("http://test/test.html?key=value?&b=c", new Dictionary<string, string> { { "key", "value?" }, { "b", "c" } });
        DecodeQueryParametersTest("http://test/test.html?key=value=what", new Dictionary<string, string> { { "key", "value=what" } });
        DecodeQueryParametersTest("http://www.google.com/search?q=energy+edge&rls=com.microsoft:en-au&ie=UTF-8&oe=UTF-8&startIndex=&startPage=1%22",
            new Dictionary<string, string>
            {
                { "q", "energy+edge" },
                { "rls", "com.microsoft:en-au" },
                { "ie", "UTF-8" },
                { "oe", "UTF-8" },
                { "startIndex", "" },
                { "startPage", "1%22" },
            });
        DecodeQueryParametersTest("http://test/test.html?key=value;key=anotherValue", new Dictionary<string, string> { { "key", "value,anotherValue" } });
    }

    private static void DecodeQueryParametersTest(string uri, Dictionary<string, string> expected)
    {
        Dictionary<string, string> parameters = new Uri(uri).DecodeQueryParameters();
        Assert.AreEqual(expected.Count, parameters.Count, "Wrong parameter count. Uri: {0}", uri);
        foreach (var key in expected.Keys)
        {
            Assert.IsTrue(parameters.ContainsKey(key), "Missing parameter key {0}. Uri: {1}", key, uri);
            Assert.AreEqual(expected[key], parameters[key], "Wrong parameter value for {0}. Uri: {1}", parameters[key], uri);
        }
    }
}

@Andrew et @CZFox

J'ai eu le même bug et j'ai trouvé la cause du fait que le paramètre un est en fait: http://www.example.com?param1et non param1ce à quoi on pourrait s'attendre.

En supprimant tous les caractères avant et en incluant le point d'interrogation, ce problème est résolu. Donc, en substance, la HttpUtility.ParseQueryStringfonction ne nécessite qu'un paramètre de chaîne de requête valide contenant uniquement des caractères après le point d'interrogation, comme dans:

HttpUtility.ParseQueryString ( "param1=good&param2=bad" )

Ma solution:

string RawUrl = "http://www.example.com?param1=good&param2=bad";
int index = RawUrl.IndexOf ( "?" );
if ( index > 0 )
    RawUrl = RawUrl.Substring ( index ).Remove ( 0, 1 );

Uri myUri = new Uri( RawUrl, UriKind.RelativeOrAbsolute);
string param1 = HttpUtility.ParseQueryString( myUri.Query ).Get( "param1" );`

Il semble que vous devriez parcourir les valeurs de myUri.Queryet les analyser à partir de là.

 string desiredValue;
 foreach(string item in myUri.Query.Split('&'))
 {
     string[] parts = item.Replace("?", "").Split('=');
     if(parts[0] == "desiredKey")
     {
         desiredValue = parts[1];
         break;
     }
 }

Je n'utiliserais pas ce code sans le tester sur un tas d'URL malformées cependant. Cela pourrait casser certains / tous ces éléments:

• hello.html?
• hello.html?valuelesskey
• hello.html?key=value=hi
• hello.html?hi=value?&b=c
• etc

Vous pouvez également utiliser la solution de contournement suivante pour qu'il fonctionne avec le premier paramètre:

var param1 =
    HttpUtility.ParseQueryString(url.Substring(
        new []{0, url.IndexOf('?')}.Max()
    )).Get("param1");

Utilisez .NET Reflector pour afficher la FillFromStringméthode de System.Web.HttpValueCollection. Cela vous donne le code qu'ASP.NET utilise pour remplir la Request.QueryStringcollection.

Ou si vous ne connaissez pas l'URL (afin d'éviter le codage en dur, utilisez le AbsoluteUri

Exemple ...

        //get the full URL
        Uri myUri = new Uri(Request.Url.AbsoluteUri);
        //get any parameters
        string strStatus = HttpUtility.ParseQueryString(myUri.Query).Get("status");
        string strMsg = HttpUtility.ParseQueryString(myUri.Query).Get("message");
        switch (strStatus.ToUpper())
        {
            case "OK":
                webMessageBox.Show("EMAILS SENT!");
                break;
            case "ER":
                webMessageBox.Show("EMAILS SENT, BUT ... " + strMsg);
                break;
        }

si vous voulez obtenir votre chaîne de requête sur la page par défaut. La page par défaut signifie l'url de votre page actuelle. vous pouvez essayer ce code:

string paramIl = HttpUtility.ParseQueryString(this.ClientQueryString).Get("city");

C'est en fait très simple, et cela a fonctionné pour moi :)

        if (id == "DK")
        {
            string longurl = "selectServer.aspx?country=";
            var uriBuilder = new UriBuilder(longurl);
            var query = HttpUtility.ParseQueryString(uriBuilder.Query);
            query["country"] = "DK";

            uriBuilder.Query = query.ToString();
            longurl = uriBuilder.ToString();
        } 

Pour tous ceux qui souhaitent parcourir toutes les chaînes de requête d'une chaîne

        foreach (var item in new Uri(urlString).Query.TrimStart('?').Split('&'))
        {
            var subStrings = item.Split('=');

            var key = subStrings[0];
            var value = subStrings[1];

            // do something with values
        }

HttpContext.Current.Request.QueryString.Get("id");

Je l'ai utilisé et il fonctionne parfaitement

<%=Request.QueryString["id"] %>