Existe um dicionário genérico somente leitura disponível no .NET?

Estou retornando uma referência a um dicionário na minha propriedade somente leitura. Como evito que os consumidores alterem meus dados? Se fosse esse, IListeu poderia simplesmente devolvê-lo AsReadOnly. Existe algo semelhante que eu possa fazer com um dicionário?

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

Aqui está uma implementação simples que envolve um dicionário:

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

Introduz o .NET Framework 4.5 BCL ReadOnlyDictionary<TKey, TValue>( origem ).

Como o BCL do .NET Framework 4.5 não inclui um AsReadOnlypara dicionários, você precisará escrever seus próprios (se desejar). Seria algo como o seguinte, cuja simplicidade talvez destaca por que não era uma prioridade para o .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 abaixo

Antes do .NET 4.5, não havia nenhuma classe de estrutura .NET que envolva um exemplo Dictionary<TKey, TValue>como o ReadOnlyCollection agrupa uma lista . No entanto, não é difícil criar um.

Aqui está um exemplo - existem muitos outros se você pesquisar no Google no ReadOnlyDictionary .

Foi anunciado na recente conferência BUILD que desde o .NET 4.5, a interface System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>está incluída. A prova está aqui (Mono) e aqui (Microsoft);)

Não tenho certeza se também ReadOnlyDictionaryestá incluído, mas pelo menos com a interface, não deve ser difícil criar agora uma implementação que exponha uma interface genérica oficial do .NET :)

Sinta-se livre para usar meu invólucro simples. Ele NÃO implementa o IDictionary, portanto, não precisa lançar exceções em tempo de execução para métodos de dicionário que alterariam o dicionário. Os métodos de mudança simplesmente não estão lá. Eu criei minha própria interface chamada 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>é herdado de ICollection<T>( IDictionary<TKey,TValue>estende ICollection<T>como ICollection<KeyValuePair<TKey,TValue>>). Ele não é usado ou implementado de forma alguma (e de fato é "oculto" pelo uso explícito da implementação dos ICollection<T>membros associados ).

Existem pelo menos três maneiras de solucionar o problema:

1. Implemente um somente leitura personalizado IDictionary<TKey, TValue>e agrupe / delegue para um dicionário interno, conforme sugerido
2. Retorne um ICollection<KeyValuePair<TKey, TValue>>conjunto como somente leitura ou IEnumerable<KeyValuePair<TKey, TValue>>dependendo do uso do valor
3. Clone o dicionário usando o construtor copy .ctor(IDictionary<TKey, TValue>)e retorne uma cópia - dessa forma, o usuário estará livre para fazer o que quiser e não terá impacto no estado do objeto que hospeda o dicionário de origem. Observe que se o dicionário que você está clonando contiver tipos de referência (não cadeias de caracteres, como mostrado no exemplo), será necessário fazer a cópia "manualmente" e clonar os tipos de referência também.

Como um aparte; ao expor coleções, tente expor a menor interface possível - no caso de exemplo, deve ser IDictionary, pois isso permite variar a implementação subjacente sem violar o contrato público que o tipo expõe.

Um dicionário somente leitura pode, até certo ponto, ser substituído por Func<TKey, TValue>- eu normalmente uso isso em uma API se eu quero apenas pessoas que realizam pesquisas; é simples e, em particular, é simples substituir o back-end, se você desejar. No entanto, não fornece a lista de chaves; se isso importa depende do que você está fazendo.

Não, mas seria fácil criar o seu próprio. IDictionary define uma propriedade IsReadOnly. Basta quebrar um dicionário e lançar uma NotSupportedException dos métodos apropriados.

Nenhum disponível na BCL. No entanto, publiquei um ReadOnlyDictionary (chamado ImmutableMap) no meu projeto BCL Extras

Além de ser um dicionário totalmente imutável, ele suporta a produção de um objeto proxy que implementa o IDictionary e pode ser usado em qualquer lugar em que o IDictionary seja utilizado. Ele emitirá uma exceção sempre que uma das APIs mutantes for chamada

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

Você pode criar uma classe que implemente apenas uma implementação parcial do dicionário e oculte todas as funções de adicionar / remover / definir.

Use um dicionário internamente para o qual a classe externa passe todas as solicitações.

No entanto, como seu dicionário provavelmente contém tipos de referência, não há como impedir o usuário de definir valores nas classes mantidas pelo dicionário (a menos que essas classes sejam apenas de leitura)

Eu não acho que exista uma maneira fácil de fazer isso ... se o seu dicionário fizer parte de uma classe personalizada, você poderá obtê-lo com um indexador:

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

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

+1 Ótimo trabalho, Thomas. Levei o ReadOnlyDictionary um passo adiante.

Muito parecido com a solução da Dale, eu queria remover Add(), Clear(), Remove(), etc de IntelliSense. Mas eu queria que meus objetos derivados fossem implementados IDictionary<TKey, TValue>.

Além disso, gostaria que o seguinte código fosse quebrado: (Novamente, a solução de Dale também faz isso)

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

A linha Add () resulta em:

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

O chamador ainda pode convertê-lo IDictionary<TKey, TValue>, mas o valor NotSupportedExceptionserá aumentado se você tentar usar os membros não somente leitura (da solução de Thomas).

Enfim, aqui está a minha solução para quem também queria isso:

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

Agora, existem coleções imutáveis ​​da Microsoft ( System.Collections.Immutable). Obtê-los via NuGet .

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

Esta é uma solução ruim, veja abaixo.

Para aqueles que ainda usam o .NET 4.0 ou anterior, tenho uma classe que funciona exatamente como a da resposta aceita, mas é muito mais curta. Ele estende o objeto Dicionário existente, substituindo (na verdade ocultando) determinados membros para que eles gerem uma exceção quando chamados.

Se o chamador tentar chamar Adicionar, Remover ou alguma outra operação de mutação que o Dicionário interno possui, o compilador lançará um erro. Eu uso os atributos obsoletos para gerar esses erros do compilador. Dessa maneira, você pode substituir um Dicionário por este ReadOnlyDictionary e ver imediatamente onde estão os problemas sem precisar executar o aplicativo e aguardar exceções em tempo de execução.

Dê uma olhada:

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

Esta solução tem um problema apontado por @supercat ilustrado aqui:

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

Em vez de fornecer um erro em tempo de compilação, como eu esperava, ou uma exceção de tempo de execução, como eu esperava, esse código é executado sem erros. Imprime quatro números. Isso faz do meu ReadOnlyDictionary um ReadWriteDictionary.