Esiste un dizionario generico di sola lettura disponibile in .NET?

Sto restituendo un riferimento a un dizionario nella mia proprietà di sola lettura. Come posso impedire ai consumatori di modificare i miei dati? Se questo fosse un, IListpotrei semplicemente restituirlo AsReadOnly. C'è qualcosa di simile che posso fare con un dizionario?

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

Ecco una semplice implementazione che avvolge un dizionario:

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

BCL .NET Framework 4.5 introduce ReadOnlyDictionary<TKey, TValue>( fonte ).

Poiché .NET Framework 4.5 BCL non include un AsReadOnlydizionario per i dizionari, sarà necessario scriverne uno proprio (se lo si desidera). Sarebbe qualcosa di simile al seguente, la cui semplicità forse evidenzia perché non fosse una priorità per .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 e versioni precedenti

Prima di .NET 4.5, non esiste una classe di framework .NET che avvolge un oggetto Dictionary<TKey, TValue>simile a ReadOnlyCollection che avvolge un elenco . Tuttavia, non è difficile crearne uno.

Ecco un esempio : ce ne sono molti altri se si utilizza Google per ReadOnlyDictionary .

È stato annunciato nella recente conferenza BUILD che da .NET 4.5 l'interfaccia System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>è inclusa. La prova è qui (Mono) e qui (Microsoft);)

Non sono sicuro che ReadOnlyDictionarysia incluso anche, ma almeno con l'interfaccia non dovrebbe essere difficile creare ora un'implementazione che espone un'interfaccia generica .NET ufficiale :)

Sentiti libero di usare il mio semplice wrapper. NON implementa IDictionary, quindi non deve generare eccezioni in fase di esecuzione per i metodi di dizionario che potrebbero modificare il dizionario. I metodi di modifica semplicemente non ci sono. Ho creato la mia interfaccia per questo chiamata 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>è ereditato da ICollection<T>( IDictionary<TKey,TValue>estende ICollection<T>come ICollection<KeyValuePair<TKey,TValue>>). Non viene utilizzato o implementato in alcun modo (ed è in effetti "nascosto" attraverso l'uso esplicito dei ICollection<T>membri associati ).

Ci sono almeno 3 modi che posso vedere per risolvere il problema:

1. Implementa una lettura personalizzata IDictionary<TKey, TValue>e esegui il wrapping / delega in un dizionario interno come è stato suggerito
2. Restituisce un ICollection<KeyValuePair<TKey, TValue>>set in sola lettura o in IEnumerable<KeyValuePair<TKey, TValue>>base all'uso del valore
3. Clonare il dizionario usando il costruttore di copie .ctor(IDictionary<TKey, TValue>)e restituire una copia - in questo modo l'utente è libero di farcela a suo piacimento e non ha alcun impatto sullo stato dell'oggetto che ospita il dizionario di origine. Nota che se il dizionario che stai clonando contiene tipi di riferimento (non stringhe come mostrato nell'esempio) dovrai eseguire la copia "manualmente" e clonare anche i tipi di riferimento.

A parte; quando si espongono le raccolte, mirare a esporre l'interfaccia più piccola possibile - nel caso di esempio dovrebbe essere IDictionary in quanto ciò consente di variare l'implementazione sottostante senza interrompere il contratto pubblico che il tipo espone.

Un dizionario di sola lettura può in qualche modo essere sostituito da Func<TKey, TValue>- Di solito lo uso in un'API se voglio solo che le persone eseguano ricerche; è semplice e, in particolare, è semplice sostituire il backend se lo desideri. Tuttavia non fornisce l'elenco di chiavi; se ciò che conta dipende da cosa stai facendo.

No, ma sarebbe facile realizzarne uno tuo. IDictionary definisce una proprietà IsReadOnly. Basta racchiudere un dizionario e generare NotSupportedException dai metodi appropriati.

Nessuno disponibile nel BCL. Tuttavia ho pubblicato un ReadOnlyDictionary (chiamato ImmutableMap) nel mio progetto BCL Extras

Oltre ad essere un dizionario completamente immutabile, supporta la produzione di un oggetto proxy che implementa IDictionary e può essere utilizzato in qualsiasi luogo in cui viene preso IDictionary. Genererà un'eccezione ogni volta che viene chiamata una delle API mutanti

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

È possibile creare una classe che implementa solo un'implementazione parziale del dizionario e nasconde tutte le funzioni Aggiungi / Rimuovi / Imposta.

Utilizzare internamente un dizionario a cui la classe esterna passa tutte le richieste.

Tuttavia, poiché è probabile che il tuo dizionario contenga tipi di riferimento, non puoi in alcun modo impedire all'utente di impostare valori sulle classi detenute dal dizionario (a meno che tali classi non siano di sola lettura)

Non penso che ci sia un modo semplice per farlo ... se il tuo dizionario fa parte di una classe personalizzata, potresti ottenerlo con un indicizzatore:

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

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

+1 Ottimo lavoro, Thomas. Ho fatto un ulteriore passo avanti su ReadOnlyDictionary.

Proprio come la soluzione di Dale, ho voluto rimuovere Add(), Clear(), Remove(), ecc da IntelliSense. Ma volevo implementare i miei oggetti derivati IDictionary<TKey, TValue>.

Inoltre, vorrei che il seguente codice si rompesse: (Anche in questo caso la soluzione di Dale fa questo)

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

La riga Aggiungi () risulta in:

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

Il chiamante può ancora lanciarlo IDictionary<TKey, TValue>, ma NotSupportedExceptionverrà sollevato se si tenta di utilizzare i membri di sola lettura (dalla soluzione di Thomas).

Comunque, ecco la mia soluzione per chiunque volesse anche questo:

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

Ora, ci sono Microsoft Immutable Collections ( System.Collections.Immutable). Farli tramite NuGet .

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

Questa è una cattiva soluzione, vedi in fondo.

Per quelli che usano ancora .NET 4.0 o precedenti, ho una classe che funziona esattamente come quella nella risposta accettata, ma è molto più breve. Estende l'oggetto Dizionario esistente, sovrascrivendo (effettivamente nascondendo) alcuni membri per far loro generare un'eccezione quando viene chiamato.

Se il chiamante prova a chiamare Aggiungi, Rimuovi o qualche altra operazione di mutazione che ha il Dizionario incorporato, il compilatore genererà un errore. Uso gli attributi Obsoleti per aumentare questi errori del compilatore. In questo modo, è possibile sostituire un dizionario con questo ReadOnlyDictionary e vedere immediatamente dove potrebbero esserci problemi senza dover eseguire l'applicazione e attendere eccezioni di runtime.

Guarda:

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

Questa soluzione presenta un problema segnalato da @supercat illustrato qui:

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

Invece di dare un errore di compilazione come mi aspettavo o un'eccezione di runtime come speravo, questo codice viene eseguito senza errori. Stampa quattro numeri. Ciò rende il mio ReadOnlyDictionary un ReadWriteDictionary.