Apakah ada kamus umum baca-saja yang tersedia di .NET?

Saya mengembalikan referensi ke kamus di properti hanya baca saya. Bagaimana cara mencegah konsumen mengubah data saya? Jika ini adalah IListsaya hanya bisa mengembalikannya AsReadOnly. Apakah ada hal serupa yang dapat saya lakukan dengan kamus?

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

Berikut ini adalah implementasi sederhana yang membungkus kamus:

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 memperkenalkan ReadOnlyDictionary<TKey, TValue>( sumber ).

Karena .NET Framework 4.5 BCL tidak menyertakan AsReadOnlykamus, Anda harus menulis sendiri (jika Anda menginginkannya). Ini akan menjadi sesuatu seperti yang berikut, kesederhanaan yang mungkin menyoroti mengapa itu bukan prioritas untuk .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 dan di bawah

Sebelum .NET 4.5, tidak ada kelas .NET framework yang membungkus Dictionary<TKey, TValue>seperti ReadOnlyCollection membungkus Daftar . Namun, tidak sulit untuk membuatnya.

Berikut ini adalah contoh - ada banyak lainnya jika Anda Google untuk ReadOnlyDictionary .

Diumumkan dalam konferensi BUILD baru-baru ini bahwa sejak .NET 4.5, antarmuka System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>disertakan. Buktinya ada di sini (Mono) dan di sini (Microsoft);)

Tidak yakin jika ReadOnlyDictionarydisertakan juga, tetapi setidaknya dengan antarmuka itu seharusnya tidak sulit untuk membuat sekarang implementasi yang memperlihatkan antarmuka .NET generik resmi :)

Jangan ragu untuk menggunakan pembungkus sederhana saya. Ini TIDAK mengimplementasikan IDictionary, sehingga tidak harus membuang pengecualian saat runtime untuk metode kamus yang akan mengubah kamus. Ubah metode sama sekali tidak ada. Saya membuat antarmuka saya sendiri untuk itu yang disebut IReadOnlyDictionary.

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>diwarisi dari ICollection<T>( IDictionary<TKey,TValue>extends ICollection<T>as ICollection<KeyValuePair<TKey,TValue>>). Itu tidak digunakan atau diimplementasikan dengan cara apa pun (dan sebenarnya "tersembunyi" melalui penggunaan secara eksplisit menerapkan ICollection<T>anggota terkait ).

Setidaknya ada 3 cara yang bisa saya lihat untuk menyelesaikan masalah:

1. Terapkan custom read only IDictionary<TKey, TValue>dan bungkus / delegasikan ke kamus dalam seperti yang disarankan
2. Kembalikan satu ICollection<KeyValuePair<TKey, TValue>>set sebagai hanya baca atau IEnumerable<KeyValuePair<TKey, TValue>>tergantung pada penggunaan nilai
3. Mengkloning kamus menggunakan copy constructor .ctor(IDictionary<TKey, TValue>)dan mengembalikan salinan - dengan cara itu pengguna bebas untuk melakukannya sesuka mereka dan itu tidak berdampak pada keadaan objek hosting kamus sumber. Perhatikan bahwa jika kamus yang Anda kloning berisi jenis referensi (bukan string seperti yang ditunjukkan dalam contoh) Anda perlu menyalinnya secara "manual" dan mengkloning jenis referensi juga.

Sebagai samping; ketika mengekspos koleksi, bertujuan untuk mengekspos antarmuka sekecil mungkin - dalam contoh kasus itu harus IDictionary karena ini memungkinkan Anda untuk memvariasikan implementasi yang mendasarinya tanpa melanggar kontrak publik yang diekspos oleh tipe tersebut.

Kamus read-only sampai batas tertentu dapat diganti dengan Func<TKey, TValue>- Saya biasanya menggunakan ini dalam API jika saya hanya ingin orang yang melakukan pencarian; itu sederhana, dan khususnya, mudah untuk mengganti backend jika Anda ingin. Namun, itu tidak memberikan daftar kunci; apakah itu penting tergantung pada apa yang Anda lakukan.

Tidak, tetapi akan mudah untuk menggulung sendiri. IDictionary mendefinisikan properti IsReadOnly. Hanya membungkus Kamus dan melempar NotSupportedException dari metode yang sesuai.

Tidak ada yang tersedia di BCL. Namun saya menerbitkan ReadOnlyDictionary (bernama ImmutableMap) di Proyek BCL Extras saya

Selain menjadi kamus yang sepenuhnya tidak dapat diubah, kamus ini juga mendukung pembuatan objek proxy yang mengimplementasikan IDictionary dan dapat digunakan di mana pun tempat IDictionary diambil. Ini akan mengeluarkan pengecualian setiap kali salah satu API yang bermutasi dipanggil

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

Anda bisa membuat kelas yang hanya mengimplementasikan sebagian implementasi kamus, dan menyembunyikan semua fungsi add / remove / set.

Gunakan kamus secara internal bahwa kelas eksternal melewati semua permintaan.

Namun, karena kamus Anda kemungkinan memegang jenis referensi, tidak mungkin Anda dapat menghentikan pengguna dari menetapkan nilai pada kelas yang dipegang oleh kamus (kecuali jika kelas itu sendiri hanya dibaca)

Saya rasa tidak ada cara mudah untuk melakukannya ... jika kamus Anda adalah bagian dari kelas khusus, Anda dapat mencapainya dengan pengindeks:

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

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

+1 Pekerjaan bagus, Thomas. Saya mengambil ReadOnlyDictionary selangkah lebih maju.

Sama seperti solusi Dale, saya ingin menghapus Add(), Clear(), Remove(), dll dari IntelliSense. Tapi saya ingin objek turunan saya diimplementasikan IDictionary<TKey, TValue>.

Selain itu, saya ingin kode berikut untuk dipecah: (Sekali lagi, solusi Dale juga melakukan ini)

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

Baris Tambahkan () menghasilkan:

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

Penelepon masih dapat IDictionary<TKey, TValue>mengirimkannya, tetapi NotSupportedExceptionakan dimunculkan jika Anda mencoba menggunakan anggota yang tidak hanya baca (dari solusi Thomas).

Bagaimanapun, inilah solusi saya untuk siapa saja yang juga menginginkan ini:

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

Sekarang, ada Microsoft Immutable Collections ( System.Collections.Immutable). Dapatkan melalui NuGet .

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

Ini adalah solusi yang buruk, lihat di bagian bawah.

Bagi mereka yang masih menggunakan .NET 4.0 atau sebelumnya, saya memiliki kelas yang berfungsi seperti yang ada di jawaban yang diterima, tetapi jauh lebih pendek. Itu memperluas objek Kamus yang ada, menimpa (sebenarnya menyembunyikan) anggota tertentu agar mereka melemparkan pengecualian saat dipanggil.

Jika pemanggil mencoba memanggil Tambah, Hapus, atau operasi mutasi lain yang dimiliki Kamus bawaan, kompiler akan membuat kesalahan. Saya menggunakan atribut Usang untuk meningkatkan kesalahan kompilator ini. Dengan cara ini, Anda dapat mengganti Kamus dengan ReadOnlyDictionary ini dan segera melihat di mana masalah mungkin tanpa harus menjalankan aplikasi Anda dan menunggu pengecualian run-time.

Lihatlah:

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

Solusi ini memiliki masalah yang ditunjukkan oleh @supercat yang diilustrasikan di sini:

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

Daripada memberikan kesalahan waktu kompilasi seperti yang saya harapkan, atau pengecualian runtime seperti yang saya harapkan, kode ini berjalan tanpa kesalahan. Mencetak empat angka. Itu membuat ReadOnlyDictionary saya menjadi ReadWriteDictionary.