Dizionario .NET: ottieni o crea nuovo

Question

Spesso mi trovo a creare un Dictionary con una classe di valore non banale (ad esempio List) e quindi a scrivere sempre lo stesso modello di codice quando compili i dati.

Ad esempio:

var dict = new Dictionary<string, List<string>>(); 
string key = "foo"; 
string aValueForKey = "bar"; 

Cioè, voglio inserire "bar" nella lista che corrisponde alla chiave "foo", dove la chiave "foo" potrebbero non essere mappati a nulla.

Questo è dove io uso il modello sempre ripetere:

List<string> keyValues; 
if (!dict.TryGetValue(key, out keyValues)) 
    dict.Add(key, keyValues = new List<string>()); 
keyValues.Add(aValueForKey); 

C'è un modo più elegante di fare questo?

domande

correlati che non hanno risposte a questa domanda:

• Is there an IDictionary implementation that returns null on missing key instead of throwing?
• Find-or-insert with only one lookup in c# dictionary
• Dictionary returning a default value if the key does not exist

Answer 1

Abbiamo una leggermente diversa su questo, ma l'effetto è simile:

public static TValue GetOrCreate<TKey, TValue>(this IDictionary<TKey, TValue> dict, TKey key) 
    where TValue : new() 
{ 
    TValue val; 

    if (!dict.TryGetValue(key, out val)) 
    { 
     val = new TValue(); 
     dict.Add(key, val); 
    } 

    return val; 
} 

Chiamato:

var dictionary = new Dictionary<string, List<int>>(); 

List<int> numbers = dictionary.GetOrCreate("key"); 

si avvale del vincolo generico per costruttori senza parametri pubblici: where TValue : new().

per aiutare con la scoperta, a meno che il metodo di estensione è abbastanza specifica a un problema stretto, si tende a mettere metodi di estensione nello spazio dei nomi del tipo stanno ampliando, in questo caso:

namespace System.Collections.Generic 

La maggior parte delle l'ora, la persona che utilizza il tipo ha l'istruzione using definita nella parte superiore, quindi IntelliSense troverà anche i metodi di estensione definiti nel codice.

Answer 2

Come con tanti problemi di programmazione, quando vi trovate a fare qualcosa di molto, il refactoring in un metodo:

public static void MyAdd<TKey, TCollection, TValue>(
    this Dictionary<TKey, TCollection> dictionary, TKey key, TValue value) 
    where TCollection : ICollection<TValue>, new() 
{ 
    TCollection collection; 
    if (!dictionary.TryGetValue(key, out collection)) 
    { 
     collection = new TCollection(); 
     dictionary.Add(key, collection); 
    } 
    collection.Add(value); 
} 

Answer 3

Ok, approccio diverso:

public static bool TryAddValue<TKey,TValue>(this System.Collections.Generic.IDictionary<TKey,List<TValue>> dictionary, TKey key, TValue value) 
    { 
     // Null check (useful or not, depending on your null checking approach) 
     if (value == null) 
      return false; 

     List<TValue> tempValue = default(List<TValue>); 

     try 
     { 
      if (!dictionary.TryGetValue(key, out tempValue)) 
      { 
       dictionary.Add(key, tempValue = new List<TValue>()); 
      } 
      else 
      { 
       // Double null check (useful or not, depending on your null checking approach) 
       if (tempValue == null) 
       { 
        dictionary[key] = (tempValue = new List<TValue>()); 
       } 
      } 

      tempValue.Add(value); 
      return true; 
     } 
     catch 
     { 
      return false; 
     } 
    } 

In questo modo si ha per "provare ad aggiungere" il tuo valore a un elenco generico di (ovviamente generalizzabile a una raccolta generica), a un controllo nullo e cercando di ottenere la chiave/i valori esistenti nel tuo dizionario. Uso e l'esempio:

var x = new Dictionary<string,List<string>>(); 
x.TryAddValue("test", null); // return false due to null value. Doesn't add the key 
x.TryAddValue("test", "ok"); // it works adding the key/value 
x.TryAddValue("test", "ok again"); // it works adding the value to the existing list 

Speranza che aiuta.

Answer 4

E che dire di questo?

var keyValues = dictionary[key] = dictionary.ContainsKey(key) ? dictionary[key] : new List<string>(); 
keyValues.Add(aValueForKey);