Existe-t-il un dictionnaire générique en lecture seule disponible dans .NET?

Je renvoie une référence à un dictionnaire dans ma propriété en lecture seule. Comment empêcher les consommateurs de modifier mes données? Si c'était un, IListje pourrais simplement le retourner AsReadOnly. Puis-je faire quelque chose de similaire avec un dictionnaire?

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

Voici une implémentation simple qui encapsule un dictionnaire:

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

Le .NET Framework 4.5 BCL introduit ReadOnlyDictionary<TKey, TValue>( source ).

Comme le .NET Framework 4.5 BCL n'inclut pas AsReadOnlyde dictionnaires for, vous devrez écrire le vôtre (si vous le souhaitez). Ce serait quelque chose comme ce qui suit, dont la simplicité souligne peut-être pourquoi ce n'était pas une priorité pour .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 et inférieur

Avant .NET 4.5, il n'y a pas de classe de framework .NET qui encapsule un Dictionary<TKey, TValue>comme ReadOnlyCollection encapsule un List . Cependant, il n'est pas difficile d'en créer un.

Voici un exemple - il y en a beaucoup d'autres si vous recherchez ReadOnlyDictionary sur Google .

Il a été annoncé lors de la récente conférence BUILD que depuis .NET 4.5, l'interface System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>est incluse. La preuve est ici (Mono) et ici (Microsoft);)

Je ne sais pas si ReadOnlyDictionaryest également inclus, mais au moins avec l'interface, il ne devrait pas être difficile de créer maintenant une implémentation qui expose une interface générique officielle .NET :)

N'hésitez pas à utiliser mon emballage simple. Il n'implémente PAS IDictionary, il n'a donc pas à lever d'exceptions lors de l'exécution pour les méthodes de dictionnaire qui modifieraient le dictionnaire. Les méthodes de changement ne sont tout simplement pas là. J'ai créé ma propre interface appelée 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>est hérité de ICollection<T>( IDictionary<TKey,TValue>s'étend en ICollection<T>tant que ICollection<KeyValuePair<TKey,TValue>>). Il n'est en aucun cas utilisé ou implémenté (et est en fait "caché" par l'utilisation de l'implémentation explicite desICollection<T> membres ).

Il y a au moins 3 façons dont je peux voir pour résoudre le problème:

1. Implémenter une lecture seule personnalisée IDictionary<TKey, TValue>et envelopper / déléguer à un dictionnaire interne comme cela a été suggéré
2. Renvoie un ICollection<KeyValuePair<TKey, TValue>>ensemble en lecture seule ou en IEnumerable<KeyValuePair<TKey, TValue>>fonction de l'utilisation de la valeur
3. Clonez le dictionnaire à l'aide du constructeur de copie .ctor(IDictionary<TKey, TValue>)et renvoyez une copie - de cette façon, l'utilisateur est libre d'en faire ce qu'il veut et cela n'a pas d'impact sur l'état de l'objet hébergeant le dictionnaire source. Notez que si le dictionnaire que vous clonez contient des types de référence (pas des chaînes comme indiqué dans l'exemple), vous devrez faire la copie "manuellement" et cloner également les types de référence.

En aparté; lors de l'exposition de collections, essayez d'exposer la plus petite interface possible - dans le cas d'exemple, il devrait s'agir de IDictionary car cela vous permet de faire varier l'implémentation sous-jacente sans rompre le contrat public que le type expose.

Un dictionnaire en lecture seule peut dans une certaine mesure être remplacé par Func<TKey, TValue>- J'utilise généralement ceci dans une API si je veux seulement que les gens effectuent des recherches; c'est simple, et en particulier, il est simple de remplacer le backend si jamais vous le souhaitez. Cependant, il ne fournit pas la liste des clés; si cela compte dépend de ce que vous faites.

Non, mais ce serait facile de rouler le vôtre. IDictionary définit une propriété IsReadOnly. Enveloppez simplement un dictionnaire et lancez une NotSupportedException à partir des méthodes appropriées.

Aucun disponible dans la BCL. Cependant, j'ai publié un ReadOnlyDictionary (nommé ImmutableMap) dans mon projet BCL Extras

En plus d'être un dictionnaire totalement immuable, il prend en charge la production d'un objet proxy qui implémente IDictionary et peut être utilisé dans n'importe quel endroit où IDictionary est pris. Il lèvera une exception chaque fois qu'une des API en mutation est appelée

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

Vous pouvez créer une classe qui n'implémente qu'une implémentation partielle du dictionnaire et masque toutes les fonctions d'ajout / suppression / ensemble.

Utilisez un dictionnaire en interne auquel la classe externe transmet toutes les requêtes.

Cependant, comme votre dictionnaire contient probablement des types de référence, il n'y a aucun moyen d'empêcher l'utilisateur de définir des valeurs sur les classes détenues par le dictionnaire (à moins que ces classes elles-mêmes ne soient en lecture seule)

Je ne pense pas qu'il y ait un moyen facile de le faire ... si votre dictionnaire fait partie d'une classe personnalisée, vous pouvez y parvenir avec un indexeur:

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

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

+1 Excellent travail, Thomas. J'ai poussé ReadOnlyDictionary un peu plus loin.

Tout comme la solution de Dale, je voulais enlever Add(), Clear(), Remove(), etc de IntelliSense. Mais je voulais que mes objets dérivés soient implémentés IDictionary<TKey, TValue>.

De plus, je voudrais que le code suivant se brise: (Encore une fois, la solution de Dale le fait aussi)

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

La ligne Add () donne:

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

L'appelant peut toujours le convertir IDictionary<TKey, TValue>, mais le NotSupportedExceptionsera déclenché si vous essayez d'utiliser les membres non en lecture seule (à partir de la solution de Thomas).

Quoi qu'il en soit, voici ma solution pour tous ceux qui voulaient aussi ceci:

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

Maintenant, il existe des collections immuables Microsoft ( System.Collections.Immutable). Obtenez-les via NuGet .

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

C'est une mauvaise solution, voir en bas.

Pour ceux qui utilisent encore .NET 4.0 ou une version antérieure, j'ai une classe qui fonctionne exactement comme celle de la réponse acceptée, mais elle est beaucoup plus courte. Il étend l'objet Dictionary existant, remplaçant (masquant en fait) certains membres pour qu'ils lèvent une exception lorsqu'ils sont appelés.

Si l'appelant essaie d'appeler Add, Remove ou une autre opération de mutation du dictionnaire intégré, le compilateur lèvera une erreur. J'utilise les attributs obsolètes pour signaler ces erreurs de compilation. De cette façon, vous pouvez remplacer un dictionnaire par ce ReadOnlyDictionary et voir immédiatement où peuvent se trouver les problèmes sans avoir à exécuter votre application et à attendre les exceptions d'exécution.

Regarde:

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

Cette solution a un problème signalé par @supercat illustré ici:

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

Plutôt que de donner une erreur de compilation comme je m'y attendais, ou une exception d'exécution comme je l'espérais, ce code s'exécute sans erreur. Il imprime quatre nombres. Cela fait de mon ReadOnlyDictionary un ReadWriteDictionary.