Existe-t-il une implémentation IDictionary qui, en cas de clé manquante, renvoie la valeur par défaut au lieu de la lancer?

L'indexeur dans Dictionary lève une exception si la clé est manquante. Existe-t-il une implémentation d'IDictionary qui renverra à la place la valeur par défaut (T)?

Je connais la méthode "TryGetValue", mais c'est impossible à utiliser avec linq.

Est-ce que cela ferait efficacement ce dont j'ai besoin?:

myDict.FirstOrDefault(a => a.Key == someKeyKalue);

Je ne pense pas que ce sera le cas, car je pense que cela itérera les clés au lieu d'utiliser une recherche de hachage.

En effet, ce ne sera pas du tout efficace.

Vous pouvez toujours écrire une méthode d'extension:

public static TValue GetValueOrDefault<TKey,TValue>
    (this IDictionary<TKey, TValue> dictionary, TKey key)
{
    TValue ret;
    // Ignore return value
    dictionary.TryGetValue(key, out ret);
    return ret;
}

Ou avec C # 7.1:

public static TValue GetValueOrDefault<TKey,TValue>
    (this IDictionary<TKey, TValue> dictionary, TKey key) =>
    dictionary.TryGetValue(key, out var ret) ? ret : default;

Cela utilise:

• Une méthode au corps d'expression (C # 6)
• Une variable out (C # 7.0)
• Un littéral par défaut (C # 7.1)

L'application de ces méthodes d'extension peut vous aider.

public static V GetValueOrDefault<K, V>(this IDictionary<K, V> dict, K key)
{
    return dict.GetValueOrDefault(key, default(V));
}

public static V GetValueOrDefault<K, V>(this IDictionary<K, V> dict, K key, V defVal)
{
    return dict.GetValueOrDefault(key, () => defVal);
}

public static V GetValueOrDefault<K, V>(this IDictionary<K, V> dict, K key, Func<V> defValSelector)
{
    V value;
    return dict.TryGetValue(key, out value) ? value : defValSelector();
}

Si quelqu'un utilise .net core 2 et supérieur (C # 7.X), la classe CollectionExtensions est introduite et peut utiliser la méthode GetValueOrDefault pour obtenir la valeur par défaut si la clé n'est pas présente dans un dictionnaire.

Dictionary<string, string> colorData = new  Dictionary<string, string>();
string color = colorData.GetValueOrDefault("colorId", string.Empty);

Collections.Specialized.StringDictionaryfournit un résultat sans exception lors de la recherche de la valeur d'une clé manquante. Il est également insensible à la casse par défaut.

Mises en garde

Il n'est valable que pour ses utilisations spécialisées et - étant conçu avant les génériques - il n'a pas un très bon énumérateur si vous avez besoin de revoir toute la collection.

Si vous utilisez .Net Core, vous pouvez utiliser la méthode CollectionExtensions.GetValueOrDefault . C'est la même chose que l'implémentation fournie dans la réponse acceptée.

public static TValue GetValueOrDefault<TKey,TValue> (
   this System.Collections.Generic.IReadOnlyDictionary<TKey,TValue> dictionary,
   TKey key);

public class DefaultIndexerDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
    private IDictionary<TKey, TValue> _dict = new Dictionary<TKey, TValue>();

    public TValue this[TKey key]
    {
        get
        {
            TValue val;
            if (!TryGetValue(key, out val))
                return default(TValue);
            return val;
        }

        set { _dict[key] = value; }
    }

    public ICollection<TKey> Keys => _dict.Keys;

    public ICollection<TValue> Values => _dict.Values;

    public int Count => _dict.Count;

    public bool IsReadOnly => _dict.IsReadOnly;

    public void Add(TKey key, TValue value)
    {
        _dict.Add(key, value);
    }

    public void Add(KeyValuePair<TKey, TValue> item)
    {
        _dict.Add(item);
    }

    public void Clear()
    {
        _dict.Clear();
    }

    public bool Contains(KeyValuePair<TKey, TValue> item)
    {
        return _dict.Contains(item);
    }

    public bool ContainsKey(TKey key)
    {
        return _dict.ContainsKey(key);
    }

    public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        _dict.CopyTo(array, arrayIndex);
    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        return _dict.GetEnumerator();
    }

    public bool Remove(TKey key)
    {
        return _dict.Remove(key);
    }

    public bool Remove(KeyValuePair<TKey, TValue> item)
    {
        return _dict.Remove(item);
    }

    public bool TryGetValue(TKey key, out TValue value)
    {
        return _dict.TryGetValue(key, out value);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return _dict.GetEnumerator();
    }
}

On pourrait définir une interface pour la fonction de recherche de clé d'un dictionnaire. Je le définirais probablement comme quelque chose comme:

Interface IKeyLookup(Of Out TValue)
  Function Contains(Key As Object)
  Function GetValueIfExists(Key As Object) As TValue
  Function GetValueIfExists(Key As Object, ByRef Succeeded As Boolean) As TValue
End Interface

Interface IKeyLookup(Of In TKey, Out TValue)
  Inherits IKeyLookup(Of Out TValue)
  Function Contains(Key As TKey)
  Function GetValue(Key As TKey) As TValue
  Function GetValueIfExists(Key As TKey) As TValue
  Function GetValueIfExists(Key As TKey, ByRef Succeeded As Boolean) As TValue
End Interface

La version avec des clés non génériques permettrait au code qui utilisait du code utilisant des types de clés non structurés de permettre une variance de clé arbitraire, ce qui ne serait pas possible avec un paramètre de type générique. On ne devrait pas être autorisé à utiliser un mutable Dictionary(Of Cat, String)comme mutable Dictionary(Of Animal, String)puisque ce dernier le permettrait SomeDictionaryOfCat.Add(FionaTheFish, "Fiona"). Mais il n'y a rien de mal à utiliser un mutable Dictionary(Of Cat, String)comme immuable Dictionary(Of Animal, String), car il SomeDictionaryOfCat.Contains(FionaTheFish)doit être considéré comme une expression parfaitement bien formée (il doit renvoyer false, sans avoir à rechercher dans le dictionnaire, tout ce qui n'est pas de type Cat).

Malheureusement, la seule façon de pouvoir réellement utiliser une telle interface est de placer un Dictionaryobjet dans une classe qui implémente l'interface. En fonction de ce que vous faites, cependant, une telle interface et la variance qu'elle permet pourraient en valoir la peine.

Si vous utilisez ASP.NET MVC, vous pouvez tirer parti de la classe RouteValueDictionary qui effectue le travail.

public object this[string key]
{
  get
  {
    object obj;
    this.TryGetValue(key, out obj);
    return obj;
  }
  set
  {
    this._dictionary[key] = value;
  }
}

Cette question a permis de confirmer que le TryGetValuejoue le FirstOrDefaultrôle ici.

Une fonctionnalité intéressante de C # 7 que je voudrais mentionner est la fonctionnalité de variables out , et si vous ajoutez l' opérateur conditionnel nul de C # 6 à l'équation, votre code pourrait être beaucoup plus simple sans avoir besoin de méthodes d'extension supplémentaires.

var dic = new Dictionary<string, MyClass>();
dic.TryGetValue("Test", out var item);
item?.DoSomething();

L'inconvénient est que vous ne pouvez pas tout faire en ligne comme ça;

dic.TryGetValue("Test", out var item)?.DoSomething();

Si nous avons besoin / voulons faire cela, nous devrions coder une méthode d'extension comme celle de Jon.

Voici une version de @ JonSkeet pour le monde de C # 7.1 qui permet également de passer une valeur par défaut facultative:

public static TV GetValueOrDefault<TK, TV>(this IDictionary<TK, TV> dict, TK key, TV defaultValue = default) => dict.TryGetValue(key, out TV value) ? value : defaultValue;

Il peut être plus efficace d'avoir deux fonctions pour optimiser le cas où vous souhaitez retourner default(TV):

public static TV GetValueOrDefault<TK, TV>(this IDictionary<TK, TV> dict, TK key, TV defaultValue) => dict.TryGetValue(key, out TV value) ? value : defaultValue;
public static TV GetValueOrDefault2<TK, TV>(this IDictionary<TK, TV> dict, TK key) {
    dict.TryGetValue(key, out TV value);
    return value;
}

Malheureusement, C # n'a pas (encore?) D'opérateur virgule (ou l'opérateur point-virgule proposé par C # 6), vous devez donc avoir un corps de fonction réel (halètement!) Pour l'une des surcharges.

J'ai utilisé l'encapsulation pour créer un IDictionary avec un comportement très similaire à une carte STL , pour ceux d'entre vous qui connaissent le c ++. Pour ceux qui ne le sont pas:

• indexer get {} dans SafeDictionary ci-dessous renvoie la valeur par défaut si une clé n'est pas présente et ajoute cette clé au dictionnaire avec une valeur par défaut. C'est souvent le comportement souhaité, car vous recherchez des éléments qui finiront par apparaître ou qui auront de bonnes chances d'apparaître.
• La méthode Add (clé TK, TV val) se comporte comme une méthode AddOrUpdate, remplaçant la valeur présente si elle existe au lieu de la lancer. Je ne vois pas pourquoi m $ n'a pas de méthode AddOrUpdate et pense que lancer des erreurs dans des scénarios très courants est une bonne idée.

TL / DR - SafeDictionary est écrit de manière à ne jamais lever d'exceptions en aucune circonstance, autres que des scénarios pervers , tels que l'ordinateur étant à court de mémoire (ou en feu). Pour ce faire, il remplace Add par le comportement AddOrUpdate et renvoie la valeur par défaut au lieu de lancer NotFoundException à partir de l'indexeur.

Voici le code:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

public class SafeDictionary<TK, TD>: IDictionary<TK, TD> {
    Dictionary<TK, TD> _underlying = new Dictionary<TK, TD>();
    public ICollection<TK> Keys => _underlying.Keys;
    public ICollection<TD> Values => _underlying.Values;
    public int Count => _underlying.Count;
    public bool IsReadOnly => false;

    public TD this[TK index] {
        get {
            TD data;
            if (_underlying.TryGetValue(index, out data)) {
                return data;
            }
            _underlying[index] = default(TD);
            return default(TD);
        }
        set {
            _underlying[index] = value;
        }
    }

    public void CopyTo(KeyValuePair<TK, TD>[] array, int arrayIndex) {
        Array.Copy(_underlying.ToArray(), 0, array, arrayIndex,
            Math.Min(array.Length - arrayIndex, _underlying.Count));
    }


    public void Add(TK key, TD value) {
        _underlying[key] = value;
    }

    public void Add(KeyValuePair<TK, TD> item) {
        _underlying[item.Key] = item.Value;
    }

    public void Clear() {
        _underlying.Clear();
    }

    public bool Contains(KeyValuePair<TK, TD> item) {
        return _underlying.Contains(item);
    }

    public bool ContainsKey(TK key) {
        return _underlying.ContainsKey(key);
    }

    public IEnumerator<KeyValuePair<TK, TD>> GetEnumerator() {
        return _underlying.GetEnumerator();
    }

    public bool Remove(TK key) {
        return _underlying.Remove(key);
    }

    public bool Remove(KeyValuePair<TK, TD> item) {
        return _underlying.Remove(item.Key);
    }

    public bool TryGetValue(TK key, out TD value) {
        return _underlying.TryGetValue(key, out value);
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return _underlying.GetEnumerator();
    }
}

Depuis .NET core 2.0, vous pouvez utiliser:

myDict.GetValueOrDefault(someKeyKalue)

Qu'en est-il de cette ligne unique qui vérifie si une clé est présente en utilisant ContainsKeyet retourne ensuite soit la valeur normalement récupérée, soit la valeur par défaut à l'aide de l'opérateur conditionnel?

var myValue = myDictionary.ContainsKey(myKey) ? myDictionary[myKey] : myDefaultValue;

Pas besoin d'implémenter une nouvelle classe Dictionary qui prend en charge les valeurs par défaut, remplacez simplement vos instructions de recherche par la ligne courte ci-dessus.

Il peut s'agir d'une ligne unique pour vérifier TryGetValueet renvoyer la valeur par défaut si c'est le cas false.

 Dictionary<string, int> myDic = new Dictionary<string, int>() { { "One", 1 }, { "Four", 4} };
 string myKey = "One"
 int value = myDic.TryGetValue(myKey, out value) ? value : 100;

myKey = "One" => value = 1

myKey = "two" => value = 100

myKey = "Four" => value = 4

Essayez-le en ligne

Non, car sinon comment sauriez-vous la différence lorsque la clé existe mais stocke une valeur nulle? Cela pourrait être important.