Słownik .NET: pobierz lub utwórz nowy

Question

Często znajduję się przy tworzeniu Dictionary z nietrywialną klasą wartości (np. List), a następnie zawsze zapisuję ten sam wzór kodu podczas wypełniania danych.

Na przykład:

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

Oznacza to, że chcę wstawić "bar" na listę, która odpowiada kluczowym "foo", gdzie klucz "foo" nie może być przypisane do niczego.

To gdzie używam stale powtarzający się wzór:

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

Czy istnieje bardziej elegancki sposób to zrobić?

Podobne pytania, które nie mają odpowiedzi na to pytanie:

• 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

Mamy nieco inne zdanie na ten temat, ale efekt jest podobne:

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

Called:

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

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

To sprawia, że ​​korzystanie z ogólnym ograniczeniem dla konstruktorów bez parametrów publicznych: where TValue : new().

Aby pomóc w odkryciu, chyba że metoda rozszerzenie jest dość specyficzny do wąskiego problemu, mamy tendencję, aby umieścić metody rozszerzenie w obszarze nazw typu są przedłużające, w tym przypadku:

namespace System.Collections.Generic 

Większość czas, osoba używająca tego typu ma zdefiniowaną na górze instrukcję using, więc IntelliSense znalazłby również metody jego rozszerzenia zdefiniowane w kodzie.

Answer 2

Jak z tak wielu problemów programowania, gdy znajdziesz się robić coś dużo, byłaby go w metodzie:

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, inne podejście:

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

W ten sposób masz aby "spróbować dodać" twoją wartość do ogólnej listy (oczywiście generalizowanej do ogólnej kolekcji), zerowej kontroli i próby uzyskania istniejących kluczy/wartości w twoim słowniku. Użycie i przykład:

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 

Mam nadzieję, że to pomaga.

Answer 4

A co z tym?

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