.NET'te salt okunur bir genel sözlük var mı?

Salt okunur özellikteki bir sözlüğe bir başvuru döndürüyorum. Tüketicilerin verilerimi değiştirmesini nasıl önleyebilirim? Bu bir olsaydı IListben sadece iade AsReadOnly. Sözlükle yapabileceğim benzer bir şey var mı?

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

İşte bir sözlüğü saran basit bir uygulama:

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 tanıtır ReadOnlyDictionary<TKey, TValue>( kaynak ).

.NET Framework 4.5 BCL'de bir AsReadOnlysözlükler bulunmadığından , kendiniz yazmanız gerekir (isterseniz). Aşağıdaki gibi bir şey olurdu, basitliği belki de neden .NET 4.5 için bir öncelik olmadığını vurgulamaktadır.

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

.NET 4.0 ve altı

.NET 4.5'ten önce Dictionary<TKey, TValue>, ReadOnlyCollection öğesinin bir Listeyi tamamlaması gibi bir .NET framework sınıfı yoktur . Ancak, bir tane oluşturmak zor değildir.

İşte bir örnek - ReadOnlyDictionary için Google iseniz başkaları da var .

Son BUILD konferansında .NET 4.5'ten beri arayüzün System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>dahil olduğu duyuruldu . Kanıt burada (Mono) ve burada (Microsoft);)

Ayrıca ReadOnlyDictionarydahil olup olmadığından emin değilim , ama en azından arayüzle resmi bir .NET jenerik arayüzünü ortaya çıkaran bir uygulama oluşturmak zor olmamalı :)

Basit paketleyicimi kullanmaktan çekinmeyin. IDictionary uygulamaz, bu nedenle sözlüğü değiştirecek sözlük yöntemleri için çalışma zamanında istisnalar atmak zorunda değildir. Değişim yöntemleri sadece orada değil. IReadOnlyDictionary adında kendi arayüzümü yaptım.

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 ile IDictionary<TKey,TValue>devralınır ICollection<T>( IDictionary<TKey,TValue>uzanır ICollection<T>olarak ICollection<KeyValuePair<TKey,TValue>>). Hiçbir şekilde kullanılmaz veya uygulanmaz (ve aslında ilişkili ICollection<T>üyeleri açıkça uygulayarak "gizlenir" ).

Sorunu çözmek için gördüğüm en az 3 yol var:

1. Özel bir salt okunur uygulama uygulayın IDictionary<TKey, TValue>ve önerildiği gibi bir iç sözlüğe sarın / delege edin
2. Bir değeri ICollection<KeyValuePair<TKey, TValue>>salt okunur olarak veya IEnumerable<KeyValuePair<TKey, TValue>>değerin kullanımına bağlı olarak döndürür
3. Kopya oluşturucuyu kullanarak sözlüğü klonlayın .ctor(IDictionary<TKey, TValue>)ve bir kopyasını gönderin - bu şekilde kullanıcı istediği gibi ücretsiz yapabilir ve kaynak sözlüğü barındıran nesnenin durumunu etkilemez. Klonladığınız sözlük referans türleri içeriyorsa (örnekte gösterildiği gibi dizeler değil) kopyalamayı "manuel olarak" yapmanız ve referans türlerini de klonlamanız gerektiğini unutmayın.

Bir yana; koleksiyonları ortaya koyarken, mümkün olan en küçük arayüzü açığa çıkarmayı hedefleyin - örnek durumda, türün ortaya çıkardığı genel sözleşmeyi bozmadan temel uygulamayı değiştirmenize izin verdiği için IDictionary olmalıdır.

Salt okunur bir sözlük bir dereceye kadar değiştirilebilir Func<TKey, TValue>- Ben genellikle sadece arama yapan kişilerin olmasını istiyorsam bunu bir API'de kullanırım; basittir ve özellikle, isterseniz arka ucun yerine koymak kolaydır. Ancak anahtarların listesini sağlamaz; bunun önemli olup olmadığı ne yaptığınıza bağlıdır.

Hayır, ama kendi başınızı döndürmek kolay olurdu. IDictionary bir IsReadOnly özelliği tanımlar. Sadece bir Sözlük sarın ve uygun yöntemlerden bir NotSupportedException atın.

Hiçbiri BCL'de mevcut değildir. Ancak bir ReadOnlyDictionary (ImmutableMap adlı) yayınladı benim BCL Ekstra

Tamamen değişmez bir sözlük olmasına ek olarak, IDictionary uygulayan ve IDictionary alınan herhangi bir yerde kullanılabilen bir proxy nesnesi üretmeyi destekler. Değişen API'lerden biri çağrıldığında bir istisna atar

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

Sözlüğün yalnızca kısmi bir uygulamasını gerçekleştiren ve tüm add / remove / set işlevlerini gizleyen bir sınıf oluşturabilirsiniz.

Harici sınıfın tüm istekleri ilettiği dahili bir sözlük kullanın.

Bununla birlikte, sözlüğünüzde muhtemelen referans türleri bulunduğundan, kullanıcının sözlük tarafından tutulan sınıflarda değer ayarlamasını engellemenin bir yolu yoktur (bu sınıfların kendileri salt okunur değilse)

Bunu yapmanın kolay bir yolu olduğunu sanmıyorum ... sözlüğünüz özel bir sınıfın parçasıysa, bunu bir dizinleyiciyle başarabilirsiniz:

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

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

+1 İyi iş Thomas. ReadOnlyDictionary bir adım daha ileri gitti.

Çok Dale'in çözüm gibi, ben kaldırmak istedim Add(), Clear(), Remove()IntelliSense dan, vb. Ama türetilen nesnelerimin uygulanmasını istedim IDictionary<TKey, TValue>.

Ayrıca, aşağıdaki kod kırmak istiyorum: (Yine, Dale'in çözümü de bunu yapar)

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

Ekle () satırı şu şekilde sonuçlanır:

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

Arayan yine de bunu yayınlayabilir IDictionary<TKey, TValue>, ancak NotSupportedExceptionsalt okunur olmayan üyeleri (Thomas'ın çözümünden) kullanmaya çalışırsanız yükseltilir.

Her neyse, işte bunu isteyen herkes için benim çözümüm:

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

Şimdi, Microsoft Bağlanabilir Koleksiyonlar ( System.Collections.Immutable) var. NuGet aracılığıyla alın .

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

Bu kötü bir çözüm, aşağıya bakın.

Hala .NET 4.0 veya önceki sürümleri kullananlar için, kabul edilen yanıttaki gibi çalışan bir sınıfım var, ancak çok daha kısa. Varolan Dictionary nesnesini genişleterek, belirli üyeleri çağrıldığında bir istisna atmalarını sağlamak için geçersiz kılar (aslında gizler).

Arayan, yerleşik Sözlüğün sahip olduğu Ekle, Kaldır veya başka bir mutasyon işlemini çağırmaya çalışırsa, derleyici bir hata atar. Bu derleyici hatalarını yükseltmek için eski öznitelikleri kullanın. Bu şekilde, bir Sözlüğü bu ReadOnlyDictionary ile değiştirebilir ve uygulamanızı çalıştırmak zorunda kalmadan ve çalışma zamanı istisnalarını beklemeden herhangi bir sorunun nerede olabileceğini hemen görebilirsiniz.

Bir göz at:

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

Bu çözüm, burada gösterilen @supercat tarafından belirtilen bir soruna sahiptir:

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

Beklediğim gibi bir derleme zamanı hatası veya umduğum gibi bir çalışma zamanı özel durumu vermek yerine, bu kod hatasız çalışır. Dört sayı basar. Bu benim ReadOnlyDictionary bir ReadWriteDictionary yapar.