Vérifier si la clé existe dans NameValueCollection

Existe-t-il un moyen rapide et simple de vérifier si une clé existe dans un NameValueCollection sans la parcourir en boucle?

Vous recherchez quelque chose comme Dictionary.ContainsKey () ou similaire.

Il existe bien sûr de nombreuses façons de résoudre ce problème. Je me demandais juste si quelqu'un pouvait m'aider à me gratter le cerveau.

Depuis MSDN :

Cette propriété renvoie null dans les cas suivants:

1) si la clé spécifiée n'est pas trouvée;

Vous pouvez donc simplement:

NameValueCollection collection = ...
string value = collection[key];
if (value == null) // key doesn't exist

2) si la clé spécifiée est trouvée et que sa valeur associée est nulle.

collection[key]appelle base.Get()alors base.FindEntry()qui utilise en interne Hashtableavec la performance O (1).

Utilisez cette méthode:

private static bool ContainsKey(this NameValueCollection collection, string key)
{
    if (collection.Get(key) == null)
    {
        return collection.AllKeys.Contains(key);
    }

    return true;
}

C'est le plus efficace pour NameValueCollectionet ne dépend pas de si la collection contient des nullvaleurs ou non.

Je ne pense pas qu'aucune de ces réponses soit tout à fait correcte / optimale. NameValueCollection ne fait pas seulement la distinction entre les valeurs nulles et les valeurs manquantes, il est également insensible à la casse en ce qui concerne ses clés. Ainsi, je pense qu'une solution complète serait:

public static bool ContainsKey(this NameValueCollection @this, string key)
{
    return @this.Get(key) != null 
        // I'm using Keys instead of AllKeys because AllKeys, being a mutable array,
        // can get out-of-sync if mutated (it weirdly re-syncs when you modify the collection).
        // I'm also not 100% sure that OrdinalIgnoreCase is the right comparer to use here.
        // The MSDN docs only say that the "default" case-insensitive comparer is used
        // but it could be current culture or invariant culture
        || @this.Keys.Cast<string>().Contains(key, StringComparer.OrdinalIgnoreCase);
}

Oui, vous pouvez utiliser Linq pour vérifier la AllKeyspropriété:

using System.Linq;
...
collection.AllKeys.Contains(key);

Cependant, un Dictionary<string, string[]>serait beaucoup plus adapté à cet objectif, peut-être créé via une méthode d'extension:

public static void Dictionary<string, string[]> ToDictionary(this NameValueCollection collection) 
{
    return collection.Cast<string>().ToDictionary(key => key, key => collection.GetValues(key));
}

var dictionary = collection.ToDictionary();
if (dictionary.ContainsKey(key))
{
   ...
}

Vous pouvez utiliser la Getméthode et vérifier nullque la méthode retournera nullsi NameValueCollection ne contient pas la clé spécifiée.

Voir MSDN .

Si la taille de la collection est petite, vous pouvez utiliser la solution fournie par rich.okelly. Cependant, une grande collection signifie que la génération du dictionnaire peut être sensiblement plus lente que la simple recherche de la collection de clés.

En outre, si votre scénario d'utilisation recherche des clés à différents moments dans le temps, où NameValueCollection a peut-être été modifié, la génération du dictionnaire à chaque fois peut, encore une fois, être plus lente que la simple recherche de la collection de clés.

Cela pourrait également être une solution sans avoir à introduire une nouvelle méthode:

    item = collection["item"] != null ? collection["item"].ToString() : null;

Comme vous pouvez le voir dans les sources de référence, NameValueCollection hérite de NameObjectCollectionBase .

Vous prenez donc le type de base, obtenez la table de hachage privée par réflexion et vérifiez si elle contient une clé spécifique.

Pour que cela fonctionne également en Mono, vous devez voir quel est le nom de la table de hachage en mono, ce que vous pouvez voir ici (m_ItemsContainer), et obtenir le champ mono, si le FieldInfo initial est nul (mono- Durée).

Comme ça

public static class ParameterExtensions
{

    private static System.Reflection.FieldInfo InitFieldInfo()
    {
        System.Type t = typeof(System.Collections.Specialized.NameObjectCollectionBase);
        System.Reflection.FieldInfo fi = t.GetField("_entriesTable", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

        if(fi == null) // Mono
            fi = t.GetField("m_ItemsContainer", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

        return fi;
    }

    private static System.Reflection.FieldInfo m_fi = InitFieldInfo();


    public static bool Contains(this System.Collections.Specialized.NameValueCollection nvc, string key)
    {
        //System.Collections.Specialized.NameValueCollection nvc = new System.Collections.Specialized.NameValueCollection();
        //nvc.Add("hello", "world");
        //nvc.Add("test", "case");

        // The Hashtable is case-INsensitive
        System.Collections.Hashtable ent = (System.Collections.Hashtable)m_fi.GetValue(nvc);
        return ent.ContainsKey(key);
    }
}

pour le code .NET 2.0 ultra-pur non réfléchissant, vous pouvez boucler sur les clés, au lieu d'utiliser la table de hachage, mais c'est lent.

private static bool ContainsKey(System.Collections.Specialized.NameValueCollection nvc, string key)
{
    foreach (string str in nvc.AllKeys)
    {
        if (System.StringComparer.InvariantCultureIgnoreCase.Equals(str, key))
            return true;
    }

    return false;
}

En VB c'est:

if not MyNameValueCollection(Key) is Nothing then
.......
end if

En C # devrait juste être:

if (MyNameValueCollection(Key) != null) { }

Je ne sais pas si cela devrait être nullou ""mais cela devrait aider.

J'utilise cette collection, quand j'ai travaillé dans la collection de petits éléments.

Là où les éléments sont nombreux, je pense qu'il faut utiliser "Dictionary". Mon code:

NameValueCollection ProdIdes;
string prodId = _cfg.ProdIdes[key];
if (string.IsNullOrEmpty(prodId))
{
    ......
}

Ou peut être utiliser ceci:

 string prodId = _cfg.ProdIdes[key] !=null ? "found" : "not found";

queryItems.AllKeys.Contains(key)

Sachez que la clé peut ne pas être unique et que la comparaison est généralement sensible à la casse. Si vous voulez simplement obtenir la valeur de la première clé correspondante et ne pas vous soucier de la casse, utilisez ceci:

        public string GetQueryValue(string queryKey)
        {
            foreach (string key in QueryItems)
            {
                if(queryKey.Equals(key, StringComparison.OrdinalIgnoreCase))
                    return QueryItems.GetValues(key).First(); // There might be multiple keys of the same name, but just return the first match
            }
            return null;
        }

NameValueCollection n = Request.QueryString;

if (n.HasKeys())
   {
       //something
   }

Type de valeur de retour: System.Boolean true si NameValueCollection contient des clés qui ne sont pas nulles; sinon, faux.LIEN