IDictionary <,> Kontrawariancja?

Question

Mam następujące metody w klasie zewnętrznej

public static void DoStuffWithAnimals(IDictionary<string, Animal> animals) 

W moim kodu wywołującego, mam już Dictionary<string, Lion> obiekt, ale nie mogę przekazać to jako argument w tej metodzie jest. Więc IDictionary<,> nie jest sprzeczny? Nie widzę żadnego powodu, dla którego to nie powinno działać.

Jedynym rozwiązaniem można myślę, jest:

var animals = new Dictionary<string, Animal>(); 

foreach(var kvp in lions) { 
    animals.Add(kvp.Key, kvp.Value); 
} 

Czy istnieje żaden sposób, aby zdać ten słownik w ten sposób, bez konieczności tworzenia nowego słownika tych samych obiektów?

---

EDIT:

Jak to jest moja metoda, wiem, że jedynym członkiem używam ze słownika jest getter od TValue this[TKey key], który jest członkiem IDictionary<TKey, TValue>, więc w tym scenariuszu , Nie mogę użyć parametru "szerszy" dla parametru.

Answer 1

Rozwiązanie mądry mógłby zrobić coś takiego, po prostu przekazać w akcesor Zamiast:

public static void DoStuffWithAnimals(Func<string, Animal> getAnimal) 
    { 
    } 

    var dicLions = new Dictionary<string, Lion>(); 
    DoStuffWithAnimals(s => dicLions[s]); 

Oczywiście, że może być trochę proste do swoich potrzeb, ale jeśli potrzebujesz tylko kilku metod słownikowych, łatwo jest je wprowadzić.

Jest to kolejny sposób, który daje trochę kodu ponownego wykorzystania między swoimi zwierzętami:

public class Accessor<T> : IAnimalAccessor where T : Animal 
    { 
     private readonly Dictionary<string, T> _dict; 

     public Accessor(Dictionary<string, T> dict) 
     { 
      _dict = dict; 
     } 

     public Animal GetItem(String key) 
     { 
      return _dict[key]; 
     } 
    } 

    public interface IAnimalAccessor 
    { 
     Animal GetItem(string key); 
    } 

    public static void DoStuffWithAnimals(IAnimalAccessor getAnimal) 
    { 
    } 

    var dicLions = new Dictionary<string, Lion>(); 
    var accessor = new Accessor<Lion>(dicLions); 
    DoStuffWithAnimals(accessor); 

Answer 2

Załóżmy, że Derived jest podtypem Base. Następnie Dictionary<Base> nie może być podtypu Dictionary<Derived> ponieważ nie można umieścić dowolny obiekt typu Base w Dictionary<Derived>, ale Dictionary<Derived> nie może być podtypem Dictionary<Base> bo jeśli się obiektu z pomocą Dictionary<Base>, może nie być Derived. W związku z tym Dictionary nie jest ani współzależny, ani sprzeczny w swoim parametrze typu.

Ogólnie rzecz biorąc, kolekcje, na które można pisać, są niezmienne z tego powodu. Jeśli masz niezmienny zbiór, to może to być kowariancja. (Jeśli miałbyś jakąś kolekcję tylko do zapisu, to może być kontrawariantem.)

EDYCJA: A jeśli miałeś "kolekcję", z której nie można było uzyskać danych ani umieścić danych, to może to być zarówno współpraca, i contravariant. (Byłoby to również prawdopodobnie bezużyteczna.)

Answer 3

Można modyfikować public static void DoStuffWithAnimals(IDictionary<string, Animal> animals) dodać rodzajowe ograniczenie. Oto coś, co działa na mnie w LINQPad:

void Main() 
{ 
    var lions = new Dictionary<string, Lion>(); 
    lions.Add("one", new Lion{Name="Ben"}); 
    AnimalManipulator.DoStuffWithAnimals(lions); 
} 

public class AnimalManipulator 
{ 
    public static void DoStuffWithAnimals<T>(IDictionary<string, T> animals) 
    where T : Animal 
    { 
     foreach (var kvp in animals) 
     { 
      kvp.Value.MakeNoise(); 
     } 
    } 
} 

public class Animal 
{ 
    public string Name {get;set;} 
    public virtual string MakeNoise() 
    { 
     return "?"; 
    } 
} 

public class Lion : Animal 
{ 
    public override string MakeNoise() 
    { 
     return "Roar"; 
    } 
} 

Answer 4

Jeśli interfejs słownika została tylko do odczytu (pozwalając tylko do odczytu par klucz-wartość, a nawet nie może pozwolić możliwość ściągania wartość o jego klucz), można go oznaczyć za pomocą modyfikatora generycznego parametru out. Jeśli interfejs słownika był tylko do zapisu (pozwalając na wstawianie wartości, ale nie na ich pobieranie lub iterację), może być oznaczony ogólnym modyfikatorem parametru in.

Można więc utworzyć interfejs samodzielnie i rozszerzyć klasę Dictionary, aby uzyskać potrzebną funkcjonalność.

Answer 5

Po pierwsze, kowariancja i kontrawariancja w języku C# ma zastosowanie tylko do interfejsów i delegatów.

Więc twoje pytanie jest naprawdę o IDictionary<TKey,TValue>.

Z tym, że na uboczu, najprościej jest tylko pamiętać, że interfejs może być tylko w wariancie/contra-variant, jeśli wszystkie wartości parametru typu są tylko przekazywane lub tylko zanikają.

Na przykład (kowariancja):

interface IReceiver<in T> // note 'in' modifier 
{ 
    void Add(T item); 
    void Remove(T item); 
} 

I (kontrawariancja):

interface IGiver<out T> // note 'out' modifier 
{ 
    T Get(int index); 
    T RemoveAt(int index); 
} 

nigdy nie mogę zapamiętać, który z nich jest kowariantna i który jest kontrawariantny, ale ostatecznie nie ma znaczenia , o ile pamiętasz to rozróżnienie.

W przypadku parametru IDictionary<TKey,TValue> oba parametry typu są używane zarówno w funkcji wejściowej, jak i wyjściowej, co oznacza, że ​​interfejs nie może być kowariancyjny lub contravariant. Jest niezmienny.

Jednak klasa Dictionary<TKey,TValue> wykonuje implementację IEnumerable<T>, która jest kowariancyjna.

Answer 6

1. Wierzę, że to, co chcesz, nazywa się kowariancją, a nie kontrawariancją.
2. Klasy w .Net nie mogą być współwystępujące, tylko interfejsy i delegaci.

3. IDictionary<TKey, TValue> nie może być kowariantna, bo to pozwoli Ci zrobić coś takiego:

   IDictionary<string, Sheep> sheep = new Dictionary<string, Sheep>(); 
   IDictionary<string, Animal> animals = sheep; 
   animals.Add("another innocent sheep", new Wolf()); 
   

4. Jest IReadOnlyDictionary<TKey, TValue> w .NET 4.5. Na pierwszy rzut oka może to być kowariancja (inny nowy interfejs, IReadOnlyList<T> jest kowariantny). Niestety, nie jest, ponieważ implementuje także IEnumerable<KeyValuePair<TKey, TValue>> i KeyValuePair<TKey, TValue> nie jest kowariantny.

5. Aby obejść ten problem, można zrobić metoda rodzajowa z przymusu parametru typu:

   void DoStuffWithAnimals<T>(IDictionary<string, T> animals) where T : Animal