如果键不存在，字典返回默认值

Question

我发现自己现在在代码中经常使用当前模式，

var dictionary = new Dictionary<type, IList<othertype>>();
// Add stuff to dictionary

var somethingElse = dictionary.ContainsKey(key) ? dictionary[key] : new List<othertype>();
// Do work with the somethingelse variable

或者有时

var dictionary = new Dictionary<type, IList<othertype>>();
// Add stuff to dictionary

IList<othertype> somethingElse;
if(!dictionary.TryGetValue(key, out somethingElse) {
    somethingElse = new List<othertype>();
}

这两种方式都感觉很迂回。我真正想要的是像

dictionary.GetValueOrDefault(key)

现在，我可以为字典类编写一个扩展方法来为我做这件事，但我认为我可能会丢失一些已经存在的东西。那么，有没有一种方法可以在不编写字典扩展方法的情况下以更“眼睛容易”的方式做到这一点？

Answer 1

---

根据评论，在 .Net Core 2+ / NetStandard 2.1+ / Net 5 中， MS 添加了扩展方法 GetValueOrDefault()

---

TryGetValue 已经将类型的默认值分配给字典，因此您可以use:

dictionary.TryGetValue(key, out value);

并忽略返回值。然而，实际上将只返回default(TValue)，而不是一些自定义默认值（更有用的是，也不是执行委托的结果）。该框架中没有任何内置的功能更强大。我建议两种扩展方法：（

public static TValue GetValueOrDefault<TKey, TValue>(
    this IDictionary<TKey, TValue> dictionary,
    TKey key,
    TValue defaultValue)
{
    return dictionary.TryGetValue(key, out var value) ? value : defaultValue;
}

public static TValue GetValueOrDefault<TKey, TValue>(
    this IDictionary<TKey, TValue> dictionary,
    TKey key,
    Func<TValue> defaultValueProvider)
{
    return dictionary.TryGetValue(key, out var value) ? value : defaultValueProvider();
}

当然，您可能想要进行参数检查:)

Answer 2

我确实喜欢扩展方法，但这里有一个简单的类，当我需要默认值时，我会不时使用它来处理字典。

我希望这只是 Dictionary 基类的一部分。

public class DictionaryWithDefault<TKey, TValue> : Dictionary<TKey, TValue>
{
  TValue _default;
  public TValue DefaultValue {
    get { return _default; }
    set { _default = value; }
  }
  public DictionaryWithDefault() : base() { }
  public DictionaryWithDefault(TValue defaultValue) : base() {
    _default = defaultValue;
  }
  public new TValue this[TKey key]
  {
    get { 
      TValue t;
      return base.TryGetValue(key, out t) ? t : _default;
    }
    set { base[key] = value; }
  }
}

不过要小心。通过子类化并使用 new（因为 override 在本机 Dictionary 类型上不可用），如果是 DictionaryWithDefault 对象向上转换为普通的 Dictionary，调用索引器将使用基本的 Dictionary 实现（如果缺少，则抛出异常）而不是子类的实现。

Answer 3

我创建了一个 DefaultableDictionary 来完全满足您的要求！

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace DefaultableDictionary {
    public class DefaultableDictionary<TKey, TValue> : IDictionary<TKey, TValue> {
        private readonly IDictionary<TKey, TValue> dictionary;
        private readonly TValue defaultValue;

        public DefaultableDictionary(IDictionary<TKey, TValue> dictionary, TValue defaultValue) {
            this.dictionary = dictionary;
            this.defaultValue = defaultValue;
        }

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

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

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

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

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

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

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

        public int Count {
            get { return dictionary.Count; }
        }

        public bool IsReadOnly {
            get { return dictionary.IsReadOnly; }
        }

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

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

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

        public bool TryGetValue(TKey key, out TValue value) {
            if (!dictionary.TryGetValue(key, out value)) {
                value = defaultValue;
            }

            return true;
        }

        public TValue this[TKey key] {
            get
            {
                try
                {
                    return dictionary[key];
                } catch (KeyNotFoundException) {
                    return defaultValue;
                }
            }

            set { dictionary[key] = value; }
        }

        public ICollection<TKey> Keys {
            get { return dictionary.Keys; }
        }

        public ICollection<TValue> Values {
            get
            {
                var values = new List<TValue>(dictionary.Values) {
                    defaultValue
                };
                return values;
            }
        }
    }

    public static class DefaultableDictionaryExtensions {
        public static IDictionary<TKey, TValue> WithDefaultValue<TValue, TKey>(this IDictionary<TKey, TValue> dictionary, TValue defaultValue ) {
            return new DefaultableDictionary<TKey, TValue>(dictionary, defaultValue);
        }
    }
}

该项目是 IDictionary 对象的简单装饰器和扩展方法，以使其易于使用。

DefaultableDictionary 将允许在字典周围创建一个包装器，该包装器在尝试访问不存在的键或枚举 IDictionary 中的所有值时提供默认值。

示例： vardictionary = new Dictionary().WithDefaultValue(5);

关于用法的博客文章。

Answer 4

不，不存在这样的东西。扩展方法是一种可行的方法，并且您为其命名 (GetValueOrDefault) 是一个不错的选择。