Obtenir des paramètres d'URL à partir d'une chaîne de caractères en .NET

Question

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

Normalement, j'aurais juste utilisé Request.Params["theThingIWant"] mais cette chaîne ne provient pas de la demande. Je peux créer un nouveau Uri comme ceci :

Uri myUri = new Uri(TheStringUrlIWantMyValueFrom);

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

Est-ce que j'ai raté quelque chose d'évident, ou n'y a-t-il pas un moyen intégré de faire cela sans créer une sorte de regex, etc ?

Answer 1

Utiliser les statiques ParseQueryString méthode de System.Web.HttpUtility 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 à l'adresse suivante http://msdn.microsoft.com/en-us/library/ms150046.aspx

Answer 2

C'est probablement ce que vous voulez

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");

Answer 3

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

Ce système est conçu pour être quelque peu tolérant vis-à-vis des chaînes de requête "malformées", c'est-à-dire qu'il n'est pas nécessaire d'avoir recours à un système d'alerte. 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));
    }
}

Test

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

Answer 4

On dirait que vous devez boucler sur les valeurs de myUri.Query et l'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;
     }
 }

Cependant, je n'utiliserais pas ce code sans le tester sur un certain nombre d'URL malformées. Il pourrait être cassé sur certaines/toutes ces URL :

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

Answer 5

@Andrew et @CZFox

J'ai eu le même bug et j'ai trouvé que la cause était que le paramètre 1 est en fait : http://www.example.com?param1 et non param1 ce qui est ce que l'on attendrait.

La suppression de tous les caractères avant et après le point d'interrogation résout ce problème. Donc, en substance, le HttpUtility.ParseQueryString ne nécessite qu'un paramètre de chaîne de requête valide ne contenant que des caractères après le point d'interrogation comme dans :

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

Ma solution de rechange :

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" );`