Dictionnaire en lecture seule en C#

J'ai un Dictionary<string, List<string>> et tenons à exposer le membre comme étant en lecture seule. Je vois que je peux le retourner comme un IReadOnlyDictionary<string, List<string>>, mais je ne peux pas comprendre comment le retourner comme un IReadOnlyDictionary<string, IReadOnlyList<string>>.

Est-il un moyen de faire cela? En c++, je venais d'utilisation de const, mais le C# n'a pas que.

Remarque que, tout simplement, à l'aide d'un IReadOnlyDictionary n'aide pas dans ce cas, parce que je veux le lire les valeurs de seulement ainsi. Il semble que la seule façon de le faire est de construire un autre IReadOnlyDictionary, et ajouter IReadOnlyList à eux.

Une autre option, qui je ne serais pas heureux avec, serait de créer un wrapper qui implémente l'interface IReadOnlyDictionary>, et de conserver une copie de l'instance d'origine, mais qui semble exagéré.

À propos d'une recherche à la place? Le Dictionnaire d'objet a la ToLookup() extension. msdn.microsoft.com/en-us/library/bb460184(v=vs. 110).aspx
Double Possible de Comment utiliser correctement IReadOnlyDictionary?
Double Possible de Est-il en lecture seule dictionnaire générique disponible dans .NET?

InformationsquelleAutor bpeikes | 2016-08-22

c#collections covariance

18

Il serait aussi facile que de moulage de l'ensemble du dictionnaire de référence de IReadOnlyDictionary<string, IReadOnlyList<string>> parce que Dictionary<TKey, TValue> implémente IReadOnlyDictionary<TKey, TValue>.

BTW, vous ne pouvez pas le faire parce que vous voulez que le List<string> valeurs IReadOnlyList<string>.

De sorte que vous besoin de quelque chose comme ceci:
```
var readOnlyDict = (IReadOnlyDictionary<string, IReadOnlyList<string>>)dict.ToDictionary(pair => pair.Key, pair => pair.Value.AsReadOnly());
```
Immuable dictionnaires

C'est juste une suggestion, mais si vous êtes à la recherche d'immuable dictionnaires, ajouter System.Les Collections.Immuable package NuGet à votre solution et vous serez en mesure de les utiliser:
```
//ImmutableDictionary<string, ImmutableList<string>>
var immutableDict = dict.ToImmutableDictionary(pair => pair.Key, pair => pair.Value.ToImmutableList());
```
En savoir plus sur Immuable des Collections ici.
- Merci! Immutables sont puissants et leur apprentissage est la valeur de l'effort. Les collections en lecture seule ne sont pas immuables, et l'OP a dit "je veux quelque chose comme des constantes..."
- Ne sera pas "ToDictionary", de créer une copie de l'ensemble du dictionnaire?
- Oui, et vous avez besoin de le faire de cette façon parce que vous ne pouvez pas lancer la liste de lecture seule liste explicite ou implicite de la fonte.
InformationsquelleAutor Matías Fidemraizer
5

Compte tenu du fait que vous êtes spécifiquement à la recherche d'une lecture seule Dictionary<string, List<string>>, vous êtes essentiellement à la recherche exactement pour un Recherche.

Le Dictionnaire d'objet a un ToLookup() extension.
- Pas exactement. Lire les Remarques de la section de Recherche de classe: A Lookup<TKey,TElement> resembles a Dictionary<TKey,TValue>. The difference is that a Dictionary<TKey,TValue> maps keys to single values, whereas a Lookup<TKey,TElement> maps keys to collections of values.
- Oui, @MladenB., mais l'OP demandé pour la valeur à un List<string>, de sorte que la recherche fonctionne parfaitement.
InformationsquelleAutor John Bustos
2

Tout d'abord, vous devrez créer un nouveau dictionnaire avec les types de contenu:
```
var dicWithReadOnlyList = dic.ToDictionary(
    kv => kv.Key,
    kv => kv.Value.AsReadOnly());
```
Alors vous pouvez simplement retourner le nouveau dictionnaire, depuis IReadOnlyDictionary est un supertype de Dictionary.

Pourquoi avez-vous besoin de faire cela? Parce que Dictionary<T, A> n'est pas un supertype de Dictionary<T, B>, même si A est un supertype de B. Pourquoi? Considérons l'exemple suivant:
```
var dic = new Dictionary<T, B>();
Dictionary<T, A> dic2 = dic;      //Imagine this were possible...

dic2.Add(someT, someA);           //...then we'd have a type violation here, since
                                  //dic2 = dic requires some B as the value.
```
En d'autres termes, TValue dans Dictionary n'est pas covariante. À partir d'un objet-orientied point de vue, la covariance devrait être possible en lecture seule version du dictionnaire, mais il y a des problèmes de succession dans la .NET framework qui empêchent ce phénomène (voir la partie commençant par "mise à JOUR" dans cette question pour plus de détails).
- Eh bien, c'est juste parce que TValue ne peut pas être covariants, mais dans ce cas je crois que List<string> est IReadOnlyList<string>. Ce n'est pas exactement A et B.
- Comment est-ce différent? Si A est un supertype de B, B est A.
- Dictionary n'auraient pas besoin d'être covariantes à l'égard de TValue, **IReadOnlyDictionary aurait besoin d'être covariantes à l'égard de TValue.
- Vrai, ce serait OK à partir d'un OO point de vue. Malheureusement, il semble y avoir des problèmes de succession dans le cadre d'empêcher que (voir le la moitié inférieure de cette question pour une explication).
- C'est IDictionary, pas IReadOnlyDictionary.
- Quand j'ai dit la moitié inférieure de la question, je parlais de la partie commençant par "mise à JOUR". Pour citer: "Il y aura une IReadOnlyDictionary<TKey, TValue> dans .NET 4.5, mais il ne sera pas covariante, soit :·/, parce qu'il dérive de IEnumerable<KeyValuePair<TKey, TValue>>, et KeyValuePair<TKey, TValue> n'est pas une interface, et donc ne peut pas être covariantes."
- La rétroaction pour améliorer la réponse est apprécié.
InformationsquelleAutor Heinzi

Si vous voulez retourner à la lecture seulement, dictionnaire mais encore être capable de muter le dictionnaire et la liste dans votre classe, vous pouvez utiliser un casting pour récupérer la liste type.

Cet exemple est un peu tiré par les cheveux, mais de montrer comment cela pourrait fonctionner.

public class MyClass
{
    Dictionary<string, IReadOnlyList<string>> _dictionary;
    public IReadOnlyDictionary<string, IReadOnlyList<string>> Dictionary { get { return _dictionary; } }

    public MyClass()
    {
        _dictionary = new Dictionary<string, IReadOnlyList<string>>();
    }

    public void AddItem(string item)
    {
        IReadOnlyList<string> readOnlyList = null;
        List<string> list = null;
        if (!_dictionary.TryGetValue(item, out readOnlyList))
        {
            list = new List<string>();
            _dictionary.Add(item, list);
        }
        else
            list = readOnlyList as List<string>;
        list.Add(item);
    }
}

Si votre objectif est d'avoir la propriété d'être immuable, puis à l'aide d'un ReadOnlyDictionary serait la meilleure option.

InformationsquelleAutor Patrick Huber

-1

https://msdn.microsoft.com/en-us/library/acdd6hb7.aspx

Vous pouvez l'utiliser pour exposer l'objet en readonly.

Vous pouvez également utiliser les propriétés get; set; et d'autoriser uniquement la chance d'être public.

Mais Matias réponse semble être plus adaptée.
- readonly types complexes comme des dictionnaires peut toujours être modifié en utilisant des méthodes comme .Add() ou .Remove()
InformationsquelleAutor TheNoob

Vous devez vous connecter pour publier un commentaire.

Immuable dictionnaires