valores - mostrar elementos de una lista c#




Método para agregar elementos nuevos o actualizar elementos existentes en el diccionario (3)

En algún código heredado, he visto el siguiente método de extensión para facilitar la adición de un nuevo elemento clave-valor o la actualización del valor, si la clave ya existe.

Método-1 (código heredado).

public static void CreateNewOrUpdateExisting<TKey, TValue>(
    this IDictionary<TKey, TValue> map, TKey key, TValue value)
{            
    if (map.ContainsKey(key))
    {
        map[key] = value;
    }
    else
    {
        map.Add(key, value);
    }
}

Sin embargo, he comprobado que map[key]=value hace exactamente el mismo trabajo. Es decir, este método podría reemplazarse con el Método-2 a continuación.

Método-2.

public static void CreateNewOrUpdateExisting<TKey, TValue>(
    this IDictionary<TKey, TValue> map, TKey key, TValue value)
{
    map[key] = value;
}

Ahora, mi pregunta es ... ¿Podría haber algún problema si reemplazo el Método 1 por el Método 2? ¿Se romperá en cualquier escenario posible?

Además, creo que solía ser la diferencia entre HashTable y Dictionary. HashTable permite actualizar un elemento o agregar un nuevo elemento mediante el uso de un indexador, mientras que el diccionario no lo hace. ¿Se ha eliminado esta diferencia en las versiones C #> 3.0?

El objetivo de este método no es lanzar una excepción si el usuario envía la misma clave-valor nuevamente, el método debe simplemente actualizar la entrada con el nuevo valor y hacer una nueva entrada si se ha enviado un nuevo par clave-valor al método. .


¿Podría haber algún problema si reemplazo el Método-1 por el Método-2?

No, simplemente usa map[key] = value . Las dos opciones son equivalentes.


Con respecto al Dictionary<> frente a Hashtable : cuando this.Insert(key, value, /* add */ false); Reflector, ves que los setters indexadores de ambas clases lo llaman. this.Insert(key, value, /* add */ false); y el parámetro add es responsable de lanzar una excepción al insertar una clave duplicada. Entonces el comportamiento es el mismo para ambas clases.


Funcionalmente, son equivalentes.

El map[key] = value rendimiento sería más rápido, ya que solo está realizando una búsqueda única en lugar de dos.

En cuanto al estilo, cuanto más corto, mejor :)

El código en la mayoría de los casos parece funcionar bien en el contexto de subprocesos múltiples. Sin embargo, no es seguro para subprocesos sin sincronización adicional.


Pregunta anterior, pero creo que debería agregar lo siguiente, aún más porque .net 4.0 ya se había lanzado en el momento en que se escribió la pregunta.

A partir de .NET 4.0, se encuentra el espacio de nombres System.Collections.Concurrent que incluye colecciones que son seguras para subprocesos.

La colección System.Collections.Concurrent.ConcurrentDictionary<> hace exactamente lo que quiere. Tiene el método AddOrUpdate() con la ventaja adicional de ser seguro para subprocesos.

Si se encuentra en un escenario de alto rendimiento y no maneja múltiples hilos, las respuestas ya dadas de map[key] = value son más rápidas.

En la mayoría de los escenarios, este beneficio de rendimiento es insignificante. Si es así, le aconsejo usar el ConcurrentDictionary porque:

  1. Está en el marco: está más probado y tú no eres el que tiene que mantener el código
  2. Es escalable: si cambia a multihilo, su código ya está preparado para ello




dictionary