new - obtener valor de un diccionario c#

No se puede agregar keyValuePair directamente al diccionario

Question

Quería agregar un KeyValuePair<T,U> a un Dictionary<T, U> y no pude. Tengo que pasar la clave y el valor por separado, lo que debe significar que el método Agregar tiene que crear un nuevo objeto KeyValuePair para insertar, que no puede ser muy eficiente. No puedo creer que no haya una Add(KeyValuePair<T, U>) en el método Agregar. ¿Alguien puede sugerir una posible razón para este aparente descuido?

Answer 1

¿Qué sería incorrecto con solo agregarlo a tu proyecto como una extensión?

namespace System.Collection.Generic
{
    public static class DictionaryExtensions
    {
        public static void AddKeyValuePair<K,V>(this IDictionary<K, V> me, KeyValuePair<K, V> other)
        {
            me.Add(other.Key, other.Value);
        }
    }
}

Answer 2

A menos que me equivoque, .NET 4.5 y 4.6 agrega la capacidad de agregar un KeyValuePair a un diccionario. (Si me equivoco, solo notifícame y eliminaré esta respuesta).

https://msdn.microsoft.com/en-us/library/cc673027%28v=vs.110%29.aspx

Desde el enlace anterior, la información relevante es este ejemplo de código:

public static void Main() 
{
    // Create a new dictionary of strings, with string keys, and 
    // access it through the generic ICollection interface. The 
    // generic ICollection interface views the dictionary as a 
    // collection of KeyValuePair objects with the same type 
    // arguments as the dictionary. 
    //
    ICollection<KeyValuePair<String, String>> openWith =
        new Dictionary<String, String>();

    // Add some elements to the dictionary. When elements are  
    // added through the ICollection<T> interface, the keys 
    // and values must be wrapped in KeyValuePair objects. 
    //
    openWith.Add(new KeyValuePair<String,String>("txt", "notepad.exe"));
    openWith.Add(new KeyValuePair<String,String>("bmp", "paint.exe"));
    openWith.Add(new KeyValuePair<String,String>("dib", "paint.exe"));
    openWith.Add(new KeyValuePair<String,String>("rtf", "wordpad.exe"));

    ...
}

Como se puede ver, se crea un nuevo objeto de tipo Diccionario y se llama openWith . Luego, se crea un nuevo objeto KVP y se agrega a openWith utilizando el método openWith .

Answer 3

Existe un método de este tipo: ICollection<KeyValuePair<K, T>>.Add pero como se implementa explícitamente , debe convertir su objeto de diccionario en esa interfaz para acceder a él.

((ICollection<KeyValuePair<KeyType, ValueType>>)myDict).Add(myPair);

Ver

• Lista de implementaciones de interfaz explícita en la página de documentación del Dictionary<K, T> (deberá desplazarse hacia abajo).
• Implementación explícita de miembros

La page sobre este método incluye un ejemplo.

Answer 4

No estoy 100% seguro, pero creo que la implementación interna de un Diccionario es una tabla Hash, lo que significa que las claves se convierten en hashes para realizar búsquedas rápidas.

Lea aquí si quiere saber más acerca de las tablas hash.

http://en.wikipedia.org/wiki/Hash_table

Answer 5

Puede utilizar la IDictionary<TKey,TValue> que proporciona este método:

IDictionary<int, string> dictionary = new Dictionary<int, string>();
dictionary.Add(new KeyValuePair<int,string>(0,"0"));
dictionary.Add(new KeyValuePair<int,string>(1,"1"));

Answer 6

Realice una copia de seguridad de un minuto ... antes de continuar por el camino de la supervisión, debe establecer si crear un nuevo KeyValuePair es realmente tan ineficiente.

En primer lugar, la clase de diccionario no se implementa internamente como un conjunto de pares clave / valor, sino como un conjunto de matrices. Aparte de eso, supongamos que solo se trata de un conjunto de KeyValuePairs y analizamos la eficiencia.

Lo primero que hay que notar es que KeyValuePair es una estructura. La implicación real de esto es que debe copiarse de la pila al montón para que se pase como parámetro de método. Cuando se agrega KeyValuePair al diccionario, se debe copiar una segunda vez para garantizar la semántica de tipo de valor.

Para pasar la clave y el valor como parámetros, cada parámetro puede ser un tipo de valor o un tipo de referencia. Si son tipos de valor, el rendimiento será muy similar a la ruta KeyValuePair. Si son tipos de referencia, esto puede ser en realidad una implementación más rápida, ya que solo se debe pasar la dirección y se debe hacer muy poca copia. Tanto en el mejor como en el peor de los casos, esta opción es ligeramente mejor que la opción KeyValuePair debido a la mayor sobrecarga de la estructura KeyValuePair.

Answer 7

Si alguien realmente hace esto aquí es una extensión

    public static void Add<T, U>(this IDictionary<T, U> dic, KeyValuePair<T, U> KVP)
    {
        dic.Add(KVP.Key, KVP.Value);
    }

pero recomendaría no hacer esto si no hay una necesidad real de hacer esto

Answer 8

el hecho de que el enumerador para la clase de diccionario devuelva un KeyValuePair no significa que sea así como se implementa internamente.

use IDictionary si realmente necesita pasar KVP porque ya los tiene en ese formato. De lo contrario, utilice la asignación o simplemente use el método Agregar.