.NET中是否有只读通用字典？

我在我的只读属性中返回对字典的引用.如何防止消费者更改我的数据？如果这是一个IList我可以简单地返回它AsReadOnly.我能用字典做些什么吗？

Private _mydictionary As Dictionary(Of String, String)
Public ReadOnly Property MyDictionary() As Dictionary(Of String, String)
    Get
        Return _mydictionary
    End Get
End Property

Jeff Yates.. 230

.NET 4.5

.NET Framework 4.5 BCL介绍ReadOnlyDictionary(源代码).

由于.NET Framework 4.5 BCL不包含AsReadOnlyfor词典,因此您需要编写自己的(如果需要).它将类似于以下内容,其简单性可能突出了它为什么不是.NET 4.5的优先级.

public static ReadOnlyDictionary AsReadOnly(
    this IDictionary dictionary)
{
    return new ReadOnlyDictionary(dictionary);
}

.NET 4.0及更低版本

在.NET 4.5之前,没有.NET框架类包装Dictionary类似于ReadOnlyCollection包装List.但是,创建一个并不困难.

这是一个例子 - 如果你是谷歌的ReadOnlyDictionary,还有很多其他的.

.NET 4.5

.NET Framework 4.5 BCL介绍ReadOnlyDictionary(源代码).

由于.NET Framework 4.5 BCL不包含AsReadOnlyfor词典,因此您需要编写自己的(如果需要).它将类似于以下内容,其简单性可能突出了它为什么不是.NET 4.5的优先级.

public static ReadOnlyDictionary AsReadOnly(
    this IDictionary dictionary)
{
    return new ReadOnlyDictionary(dictionary);
}

.NET 4.0及更低版本

在.NET 4.5之前,没有.NET框架类包装Dictionary类似于ReadOnlyCollection包装List.但是,创建一个并不困难.

这是一个例子 - 如果你是谷歌的ReadOnlyDictionary,还有很多其他的.

这是一个包装字典的简单实现:

public class ReadOnlyDictionary : IDictionary
{
    private readonly IDictionary _dictionary;

    public ReadOnlyDictionary()
    {
        _dictionary = new Dictionary();
    }

    public ReadOnlyDictionary(IDictionary dictionary)
    {
        _dictionary = dictionary;
    }

    #region IDictionary Members

    void IDictionary.Add(TKey key, TValue value)
    {
        throw ReadOnlyException();
    }

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

    public ICollection Keys
    {
        get { return _dictionary.Keys; }
    }

    bool IDictionary.Remove(TKey key)
    {
        throw ReadOnlyException();
    }

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

    public ICollection Values
    {
        get { return _dictionary.Values; }
    }

    public TValue this[TKey key]
    {
        get
        {
            return _dictionary[key];
        }
    }

    TValue IDictionary.this[TKey key]
    {
        get
        {
            return this[key];
        }
        set
        {
            throw ReadOnlyException();
        }
    }

    #endregion

    #region ICollection> Members

    void ICollection>.Add(KeyValuePair item)
    {
        throw ReadOnlyException();
    }

    void ICollection>.Clear()
    {
        throw ReadOnlyException();
    }

    public bool Contains(KeyValuePair item)
    {
        return _dictionary.Contains(item);
    }

    public void CopyTo(KeyValuePair[] array, int arrayIndex)
    {
        _dictionary.CopyTo(array, arrayIndex);
    }

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

    public bool IsReadOnly
    {
        get { return true; }
    }

    bool ICollection>.Remove(KeyValuePair item)
    {
        throw ReadOnlyException();
    }

    #endregion

    #region IEnumerable> Members

    public IEnumerator> GetEnumerator()
    {
        return _dictionary.GetEnumerator();
    }

    #endregion

    #region IEnumerable Members

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

    #endregion

    private static Exception ReadOnlyException()
    {
        return new NotSupportedException("This dictionary is read-only");
    }
}

public interface IReadOnlyDictionary : IEnumerable
{
    bool ContainsKey(TKey key);
    ICollection Keys { get; }
    ICollection Values { get; }
    int Count { get; }
    bool TryGetValue(TKey key, out TValue value);
    TValue this[TKey key] { get; }
    bool Contains(KeyValuePair item);
    void CopyTo(KeyValuePair[] array, int arrayIndex);
    IEnumerator> GetEnumerator();
}

public class ReadOnlyDictionary : IReadOnlyDictionary
{
    readonly IDictionary _dictionary;
    public ReadOnlyDictionary(IDictionary dictionary)
    {
        _dictionary = dictionary;
    }
    public bool ContainsKey(TKey key) { return _dictionary.ContainsKey(key); }
    public ICollection Keys { get { return _dictionary.Keys; } }
    public bool TryGetValue(TKey key, out TValue value) { return _dictionary.TryGetValue(key, out value); }
    public ICollection Values { get { return _dictionary.Values; } }
    public TValue this[TKey key] { get { return _dictionary[key]; } }
    public bool Contains(KeyValuePair item) { return _dictionary.Contains(item); }
    public void CopyTo(KeyValuePair[] array, int arrayIndex) { _dictionary.CopyTo(array, arrayIndex); }
    public int Count { get { return _dictionary.Count; } }
    public IEnumerator> GetEnumerator() { return _dictionary.GetEnumerator(); }
    IEnumerator IEnumerable.GetEnumerator() { return _dictionary.GetEnumerator(); }
}