В чем разница между двумя видами использования дженериков (ковариация)

Question

Я думаю, что я понимаю, что дженерики не поддерживают ковариацию, поэтому первый пример не работает и дает исключение Invalid Cast. Все компилируется.

Но почему работает второй пример? Я могу видеть, что это одно и то же.

MyClass как это:

public interface IGenericClass<T> { } 
public class MyClass : IGenericClass<SomeType> 
{ 
} 

не работает:

public class SendingEmail<T> 
{ 
    IGenericClass<T> abc; 
    public void Send(IGenericClass<T> _abc) 
    { 
     this.abc = _abc; 
    } 
} 

Использование:

var myClass = new MyClass(); 
SendingEmail<MyClass> sendingEmail = new SendingEmail<MyClass>(); 
sendingEmail.Send(IGenericClass<MyClass>myClass); 
//sendingEmail.Send(myClass); This was wrong 

Также пробовал:

Удалены как он никогда не компилируется

---

Working:

class SendingEmail 
{ 
    void Send<T>(MyGenericClass<T> abc) 
    { 

    } 
} 

Использование:

SendingEmail sendingEmail = new SendingEmail(); 
sendingEmail.Send(myclass); 

Answer 1

Первый пример не имеет ничего общего с ковариации. Вы просто сбиваете с толку то, что на самом деле T; T - SomeType, его не MyClass.

Во втором примере вы даете компилятору вывод правильного типа и поэтому он работает.

Редактировать

Редактирование на ваш вопрос не решить эту проблему, вы до сих пор смущает то, что T является: в MyClassT является SomeType. В SendingEmail<T>T Должно также be SomeType потому что abc напечатано IGenericType<T>, и вы в конечном счете хотите, чтобы это было IGenericType<SomeType>.

В вашем коде вы создаете экземпляр с кодом SendingEMail<MyClass>, который будет означать, что abc действительно напечатан IGenericType<MyClass>, что не так; Вы не можете преобразовать IGenericType<SomeType> в IGenericType<IGenericType<SomeClass>>, что вы действительно делаете при звонке sendingEMail(MyClass);

Что вам нужно сделать: var sendingEmail = new SendingEmail<SomeType>().

Об этом связано с дисперсией типа, это не так. Тип дисперсии - это то, что позволяет вам делать IEnumerable<Animal> animals = Enumerable.Emtpy<Tiger>(), и запрещает вам делать то же самое с IList<T>; IEnumerable является ковариантным в T, в то время как IList является инвариантным в T.

Обратите внимание, что C# имеет сломанную ковариацию в массивах, следующее правовое: Animal[] animals = new Tiger[3]. Это сломано, потому что теперь вы можете законно делать animals[0] = new Turtle(); и ... ох ... у вас просто есть исключение во время выполнения. Этот сценарий является именно тем, почему IList инвариантен в T. Почему C# нарушает ковариацию в массивах? Я не знаю, но считаю это неудачным (хотя, вероятно, оправданным) дизайнерским решением.