Compruebe si la clave existe en NameValueCollection

¿Hay una manera rápida y simple de verificar si existe una clave en una NameValueCollection sin recorrerla?

Buscando algo como Dictionary.ContainsKey () o similar.

Hay muchas formas de resolver esto, por supuesto. Solo me pregunto si alguien puede ayudar a rascarme la picazón del cerebro.

De MSDN :

Esta propiedad devuelve nulo en los siguientes casos:

1) si no se encuentra la clave especificada;

Entonces puedes simplemente:

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

2) si se encuentra la clave especificada y su valor asociado es nulo.

collection[key]llama a base.Get()continuación, base.FindEntry()que utiliza internamente Hashtablecon el rendimiento O (1).

Usa este método:

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

    return true;
}

Es el más eficiente NameValueCollectiony no depende de si la colección contiene nullvalores o no.

No creo que ninguna de estas respuestas sea correcta / óptima. NameValueCollection no solo no distingue entre valores nulos y valores perdidos, sino que también distingue entre mayúsculas y minúsculas con respecto a sus claves. Por lo tanto, creo que una solución completa sería:

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

Sí, puede usar Linq para verificar la AllKeyspropiedad:

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

Sin embargo, a Dictionary<string, string[]>sería mucho más adecuado para este propósito, tal vez creado mediante un método de extensión:

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))
{
   ...
}

Puede usar el Getmétodo y verificarlo, nullya que el método devolverá nullsi NameValueCollection no contiene la clave especificada.

Ver MSDN .

Si el tamaño de la colección es pequeño, puede optar por la solución proporcionada por rich.okelly. Sin embargo, una gran colección significa que la generación del diccionario puede ser notablemente más lenta que solo buscar en la colección de claves.

Además, si su escenario de uso está buscando claves en diferentes puntos en el tiempo, donde NameValueCollection puede haber sido modificado, generar el diccionario cada vez puede, una vez más, ser más lento que simplemente buscar en la colección de claves.

Esto también podría ser una solución sin tener que introducir un nuevo método:

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

Como puede ver en las fuentes de referencia, NameValueCollection hereda de NameObjectCollectionBase .

Entonces, toma el tipo base, obtiene la tabla hash privada a través de la reflexión y verifica si contiene una clave específica.

Para que funcione también en Mono, debe ver cuál es el nombre de la tabla hash en mono, que es algo que puede ver aquí (m_ItemsContainer), y obtener el campo mono, si FieldInfo inicial es nulo (mono- tiempo de ejecución).

Me gusta esto

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

para el código .NET 2.0 ultrapuro no reflectante, puede recorrer las teclas, en lugar de usar la tabla hash, pero eso es lento.

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 es:

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

En C # solo debería ser:

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

No estoy seguro de si debería ser nullo debería ser ""útil.

Estoy usando esta colección, cuando trabajé en la colección de elementos pequeños.

Cuando los elementos son muchos, creo que necesito usar "Diccionario". Mi código:

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

O se puede usar esto:

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

queryItems.AllKeys.Contains(key)

Tenga en cuenta que la clave puede no ser única y que la comparación suele ser sensible a mayúsculas y minúsculas. Si desea obtener el valor de la primera clave coincidente y no se preocupa por el caso, use esto:

        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
   }

Tipo de valor de retorno: System.Boolean verdadero si NameValueCollection contiene claves que no son nulas; de lo contrario, falso. ENLACE