Método de eliminación concurrentemente concurrente de ConcurrentDictionary

Question

Estaba buscando un método en ConcurrentDictionary que me permitiera eliminar una entrada por clave, si y solo si el valor es igual al que especifico, algo así como el equivalente de TryUpdate, pero para remociones.

El único método que hace esto parece ser el siguiente método:

ICollection<KeyValuePair<K, V>>.Remove(KeyValuePair<K, V> keyValuePair) 

Es la aplicación explícita de la interfaz ICollection, en otras palabras, tiene que emitir mi ConcurrentDictionary a un ICollection primero para que me puede llamar a Eliminar.

Quitar hace exactamente lo que quiero, y que reparto es nada del otro mundo tampoco, también se muestra el código fuente se llama al método privado TryRemovalInternal con bool matchValue = true, por lo que todo parece agradable y limpio.

Lo que me preocupa un poco, sin embargo, es el hecho de que no se documenta como el método Remove optimismo concurrente de ConcurrentDictionary, por lo http://msdn.microsoft.com/en-us/library/dd287153.aspx simplemente duplica la ICollection repetitivo, y la How to: Add and Remove Items from a ConcurrentDictionary no menciona que el método sea.

¿Alguien sabe si ese es el camino a seguir, o hay algún otro método que me falta?

Answer 1

Aunque no es un documento oficial, this MSDN blog post puede ser útil. La esencia de ese artículo: enviar a ICollection y llamar a su método Remove, tal como se describe en la pregunta, es el camino a seguir.

He aquí un fragmento de la entrada en el blog anterior, que lo envuelve en un métodos TryRemove de extensión:

public static bool TryRemove<TKey, TValue>(
    this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, TValue value) 
{ 
    if (dictionary == null) 
     throw new ArgumentNullException("dictionary"); 
    return ((ICollection<KeyValuePair<TKey, TValue>>)dictionary).Remove(
     new KeyValuePair<TKey, TValue>(key, value)); 
} 

Answer 2

Si usted no necesita todas las campanas & silbidos de ConcurrentDictionary, sólo se puede declarar su tipo que un IDictionary.

public class ClassThatNeedsDictionary 
{ 
    private readonly IDictionary<string, string> storage; 

    public ClassThatNeedsDictionary() 
    { 
     storage = new ConcurrentDictionary<string, string>(); 
    } 

    public void TheMethod() 
    { 
     //still thread-safe 
     this.storage.Add("key", "value"); 
     this.storage.Remove("key"); 
    } 
} 

Me parece útil en la situación en la que sólo se necesita agregar y quitar, pero todavía quiere una iteración de subprocesos.