Có một từ điển chung chỉ đọc có sẵn trong .NET không?

Tôi đang trả lại một tham chiếu đến một từ điển trong tài sản chỉ đọc của tôi. Làm cách nào để ngăn người tiêu dùng thay đổi dữ liệu của tôi? Nếu đây là một IListtôi chỉ có thể trả lại nó AsReadOnly. Có điều gì tương tự tôi có thể làm với một từ điển?

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

Đây là một cách thực hiện đơn giản bao bọc một từ điển:

public class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
    private readonly IDictionary<TKey, TValue> _dictionary;

    public ReadOnlyDictionary()
    {
        _dictionary = new Dictionary<TKey, TValue>();
    }

    public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary)
    {
        _dictionary = dictionary;
    }

    #region IDictionary<TKey,TValue> Members

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

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

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

    bool IDictionary<TKey, TValue>.Remove(TKey key)
    {
        throw ReadOnlyException();
    }

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

    public ICollection<TValue> Values
    {
        get { return _dictionary.Values; }
    }

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

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

    #endregion

    #region ICollection<KeyValuePair<TKey,TValue>> Members

    void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
    {
        throw ReadOnlyException();
    }

    void ICollection<KeyValuePair<TKey, TValue>>.Clear()
    {
        throw ReadOnlyException();
    }

    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 int Count
    {
        get { return _dictionary.Count; }
    }

    public bool IsReadOnly
    {
        get { return true; }
    }

    bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
    {
        throw ReadOnlyException();
    }

    #endregion

    #region IEnumerable<KeyValuePair<TKey,TValue>> Members

    public IEnumerator<KeyValuePair<TKey, TValue>> 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");
    }
}

.NET 4.5

.NET Framework 4.5 BCL giới thiệu ReadOnlyDictionary<TKey, TValue>( nguồn ).

Vì .NET Framework 4.5 BCL không bao gồm AsReadOnlytừ điển, bạn sẽ cần phải viết từ điển của riêng bạn (nếu bạn muốn). Nó sẽ giống như sau, sự đơn giản có lẽ làm nổi bật lý do tại sao nó không phải là ưu tiên của .NET 4.5.

public static ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(
    this IDictionary<TKey, TValue> dictionary)
{
    return new ReadOnlyDictionary<TKey, TValue>(dictionary);
}

.NET 4.0 trở xuống

Trước .NET 4.5, không có lớp .NET framework nào Dictionary<TKey, TValue>giống như ReadOnlyCollection bao bọc một Danh sách . Tuy nhiên, không khó để tạo ra một.

Dưới đây là một ví dụ - có nhiều người khác nếu bạn Google cho ReadOnlyDipedia .

Nó đã được công bố trong hội nghị BUILD gần đây rằng kể từ .NET 4.5, giao diện System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>được bao gồm. Bằng chứng là ở đây (Mono) và ở đây (Microsoft);)

Không chắc chắn nếu ReadOnlyDictionaryđược bao gồm quá, nhưng ít nhất với giao diện, không khó để tạo ra một triển khai hiển thị giao diện chung .NET chính thức :)

Hãy sử dụng trình bao bọc đơn giản của tôi. Nó KHÔNG thực hiện IDadata, vì vậy nó không phải ném ngoại lệ vào thời gian chạy cho các phương thức từ điển sẽ thay đổi từ điển. Thay đổi phương pháp đơn giản là không có. Tôi đã tạo giao diện của riêng mình cho nó được gọi là IReadOnlyDipedia.

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

public class ReadOnlyDictionary<TKey, TValue> : IReadOnlyDictionary<TKey, TValue>
{
    readonly IDictionary<TKey, TValue> _dictionary;
    public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary)
    {
        _dictionary = dictionary;
    }
    public bool ContainsKey(TKey key) { return _dictionary.ContainsKey(key); }
    public ICollection<TKey> Keys { get { return _dictionary.Keys; } }
    public bool TryGetValue(TKey key, out TValue value) { return _dictionary.TryGetValue(key, out value); }
    public ICollection<TValue> Values { get { return _dictionary.Values; } }
    public TValue this[TKey key] { get { return _dictionary[key]; } }
    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 int Count { get { return _dictionary.Count; } }
    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() { return _dictionary.GetEnumerator(); }
    IEnumerator IEnumerable.GetEnumerator() { return _dictionary.GetEnumerator(); }
}

IsReadOnly on IDictionary<TKey,TValue>được kế thừa từ ICollection<T>( IDictionary<TKey,TValue>kéo dài ICollection<T>như ICollection<KeyValuePair<TKey,TValue>>). Nó không được sử dụng hoặc thực hiện theo bất kỳ cách nào (và trên thực tế là "ẩn" thông qua việc sử dụng thực hiện rõ ràng các ICollection<T>thành viên liên quan ).

Có ít nhất 3 cách tôi có thể thấy để giải quyết vấn đề:

1. Thực hiện chỉ đọc tùy chỉnh IDictionary<TKey, TValue>và bọc / ủy quyền cho một từ điển bên trong như đã được đề xuất
2. Trả về một ICollection<KeyValuePair<TKey, TValue>>bộ dưới dạng chỉ đọc hoặc IEnumerable<KeyValuePair<TKey, TValue>>tùy thuộc vào việc sử dụng giá trị
3. Sao chép từ điển bằng cách sử dụng hàm tạo sao chép .ctor(IDictionary<TKey, TValue>)và trả về một bản sao - theo cách đó người dùng có thể tự do làm điều đó khi họ muốn và nó không ảnh hưởng đến trạng thái của đối tượng lưu trữ từ điển nguồn. Lưu ý rằng nếu từ điển bạn đang nhân bản chứa các loại tham chiếu (không phải chuỗi như trong ví dụ), bạn sẽ cần thực hiện sao chép "thủ công" và sao chép các loại tham chiếu.

Như một bên; khi trưng ra các bộ sưu tập, hãy nhắm đến việc phơi bày giao diện nhỏ nhất có thể - trong trường hợp ví dụ, nó phải là IDadata vì điều này cho phép bạn thay đổi việc triển khai cơ bản mà không phá vỡ hợp đồng công khai mà loại đó lộ ra.

Từ điển chỉ đọc có thể được thay thế ở một mức độ nào đó Func<TKey, TValue>- Tôi thường sử dụng từ này trong API nếu tôi chỉ muốn mọi người thực hiện tra cứu; thật đơn giản và đặc biệt, thật đơn giản để thay thế phần phụ trợ mà bạn muốn. Nó không cung cấp danh sách các khóa, tuy nhiên; cho dù vấn đề đó phụ thuộc vào những gì bạn đang làm.

Không, nhưng nó sẽ dễ dàng để cuộn của riêng bạn. IDadata không định nghĩa một thuộc tính IsReadOnly. Chỉ cần bọc Từ điển và ném NotSupportedException từ các phương thức thích hợp.

Không có sẵn trong BCL. Tuy nhiên, tôi đã xuất bản một ReadOnlyDipedia (có tên là ImmutableMap) trong Dự án Extras BCL của tôi

Ngoài việc là một từ điển hoàn toàn bất biến, nó còn hỗ trợ tạo ra một đối tượng proxy thực hiện IDadata và có thể được sử dụng ở bất kỳ nơi nào mà IDadata được sử dụng. Nó sẽ đưa ra một ngoại lệ bất cứ khi nào một trong các API đột biến được gọi

void Example() { 
  var map = ImmutableMap.Create<int,string>();
  map = map.Add(42,"foobar");
  IDictionary<int,string> dictionary = CollectionUtility.ToIDictionary(map);
}

Bạn có thể tạo một lớp chỉ thực hiện triển khai một phần từ điển và ẩn tất cả các hàm add / remove / set.

Sử dụng một từ điển bên trong mà lớp bên ngoài chuyển tất cả các yêu cầu đến.

Tuy nhiên, vì từ điển của bạn có khả năng giữ các loại tham chiếu, nên không có cách nào bạn ngăn người dùng thiết lập giá trị trên các lớp được giữ bởi từ điển (trừ khi chính các lớp đó chỉ được đọc)

Tôi không nghĩ rằng có một cách dễ dàng để làm điều đó ... nếu từ điển của bạn là một phần của lớp tùy chỉnh, bạn có thể đạt được nó với một người lập chỉ mục:

public class MyClass
{
  private Dictionary<string, string> _myDictionary;

  public string this[string index]
  {
    get { return _myDictionary[index]; }
  }
}

+1 Công việc tuyệt vời, Thomas. Tôi đã đọc ReadOnlyDixi một bước nữa.

Giống như giải pháp của Dale, tôi muốn loại bỏ Add(), Clear(), Remove(), vv từ IntelliSense. Nhưng tôi muốn các đối tượng dẫn xuất của tôi thực hiện IDictionary<TKey, TValue>.

Hơn nữa, tôi muốn phá vỡ đoạn mã sau: (Một lần nữa, giải pháp của Dale cũng làm điều này)

ReadOnlyDictionary<int, int> test = new ReadOnlyDictionary<int,int>(new Dictionary<int, int> { { 1, 1} });
test.Add(2, 1);  //CS1061

Dòng Add () cho kết quả:

error CS1061: 'System.Collections.Generic.ReadOnlyDictionary<int,int>' does not contain a definition for 'Add' and no extension method 'Add' accepting a first argument 

Người gọi vẫn có thể chuyển nó tới IDictionary<TKey, TValue>, nhưng NotSupportedExceptionsẽ được nâng lên nếu bạn cố gắng sử dụng các thành viên không chỉ đọc (từ giải pháp của Thomas).

Dù sao, đây là giải pháp của tôi cho bất cứ ai cũng muốn điều này:

namespace System.Collections.Generic
{
    public class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
    {
        const string READ_ONLY_ERROR_MESSAGE = "This dictionary is read-only";

        protected IDictionary<TKey, TValue> _Dictionary;

        public ReadOnlyDictionary()
        {
            _Dictionary = new Dictionary<TKey, TValue>();
        }

        public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary)
        {
            _Dictionary = dictionary;
        }

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

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

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

        public ICollection<TValue> Values
        {
            get { return _Dictionary.Values; }
        }

        public TValue this[TKey key]
        {
            get { return _Dictionary[key]; }
            set { throw new NotSupportedException(READ_ONLY_ERROR_MESSAGE); }
        }

        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 int Count
        {
            get { return _Dictionary.Count; }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

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

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

        void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
        {
            throw new NotSupportedException(READ_ONLY_ERROR_MESSAGE);
        }

        bool IDictionary<TKey, TValue>.Remove(TKey key)
        {
            throw new NotSupportedException(READ_ONLY_ERROR_MESSAGE);
        }

        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
        {
            throw new NotSupportedException(READ_ONLY_ERROR_MESSAGE);
        }

        void ICollection<KeyValuePair<TKey, TValue>>.Clear()
        {
            throw new NotSupportedException(READ_ONLY_ERROR_MESSAGE);
        }

        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
        {
            throw new NotSupportedException(READ_ONLY_ERROR_MESSAGE);
        }
    }
}

Bây giờ, có Bộ sưu tập bất biến của Microsoft ( System.Collections.Immutable). Nhận chúng qua NuGet .

public IEnumerable<KeyValuePair<string, string>> MyDictionary()
{
    foreach(KeyValuePair<string, string> item in _mydictionary)
        yield return item;
}

Đây là một giải pháp tồi, xem ở phía dưới.

Đối với những người vẫn đang sử dụng .NET 4.0 trở về trước, tôi có một lớp hoạt động giống như câu trả lời được chấp nhận, nhưng nó ngắn hơn nhiều. Nó mở rộng đối tượng Từ điển hiện có, ghi đè (thực sự ẩn) một số thành viên nhất định để họ ném ngoại lệ khi được gọi.

Nếu người gọi cố gắng gọi Thêm, Xóa hoặc một số thao tác đột biến khác mà Từ điển tích hợp có, trình biên dịch sẽ đưa ra lỗi. Tôi sử dụng các thuộc tính lỗi thời để nâng cao các lỗi biên dịch này. Bằng cách này, bạn có thể thay thế một Từ điển bằng ReadOnlyDipedia này và ngay lập tức xem mọi vấn đề có thể xảy ra mà không cần phải chạy ứng dụng của bạn và chờ ngoại lệ trong thời gian chạy.

Hãy xem:

public class ReadOnlyException : Exception
{
}

public class ReadOnlyDictionary<TKey, TValue> : Dictionary<TKey, TValue>
{
    public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary)
        : base(dictionary) { }

    public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer)
        : base(dictionary, comparer) { }

    //The following four constructors don't make sense for a read-only dictionary

    [Obsolete("Not Supported for ReadOnlyDictionaries", true)]
    public ReadOnlyDictionary() { throw new ReadOnlyException(); }

    [Obsolete("Not Supported for ReadOnlyDictionaries", true)]
    public ReadOnlyDictionary(IEqualityComparer<TKey> comparer) { throw new ReadOnlyException(); }

    [Obsolete("Not Supported for ReadOnlyDictionaries", true)]
    public ReadOnlyDictionary(int capacity) { throw new ReadOnlyException(); }

    [Obsolete("Not Supported for ReadOnlyDictionaries", true)]
    public ReadOnlyDictionary(int capacity, IEqualityComparer<TKey> comparer) { throw new ReadOnlyException(); }


    //Use hiding to override the behavior of the following four members
    public new TValue this[TKey key]
    {
        get { return base[key]; }
        //The lack of a set accessor hides the Dictionary.this[] setter
    }

    [Obsolete("Not Supported for ReadOnlyDictionaries", true)]
    public new void Add(TKey key, TValue value) { throw new ReadOnlyException(); }

    [Obsolete("Not Supported for ReadOnlyDictionaries", true)]
    public new void Clear() { throw new ReadOnlyException(); }

    [Obsolete("Not Supported for ReadOnlyDictionaries", true)]
    public new bool Remove(TKey key) { throw new ReadOnlyException(); }
}

Giải pháp này có một vấn đề được chỉ ra bởi @supercat được minh họa ở đây:

var dict = new Dictionary<int, string>
{
    { 1, "one" },
    { 2, "two" },
    { 3, "three" },
};

var rodict = new ReadOnlyDictionary<int, string>(dict);
var rwdict = rodict as Dictionary<int, string>;
rwdict.Add(4, "four");

foreach (var item in rodict)
{
    Console.WriteLine("{0}, {1}", item.Key, item.Value);
}

Thay vì đưa ra lỗi thời gian biên dịch như tôi mong đợi hoặc ngoại lệ thời gian chạy như tôi hy vọng, mã này chạy không có lỗi. Nó in bốn số. Điều đó làm cho ReadOnlyDixi của tôi trở thành ReadWriteDipedia.