Депутатская ковариационная путаница.

Question

Почему это не работает? Правильно ли я понимаю ковариантность делегатов?

public delegate void MyDelegate(object obj) 

public class MyClass 
{ 
    public MyClass() 
    { 
     //Error: Expected method with 'void MyDelegate(object)' signature 
     _delegate = MyMethod; 
    } 

    private MyDelegate _delegate; 

    public void MyMethod(SomeObject obj) 
    {} 

} 

Answer 1

Правильно - вы не понимаете ковариации правильно - пока :) Ваш код будет работать, если у вас одни и те же типы, но, как возврата значения, как это:

public delegate object MyDelegate() 

public class MyClass 
{ 
    public MyClass() 
    { 
     _delegate = MyMethod; 
    } 

    private MyDelegate _delegate; 

    public SomeObject MyMethod() { return null; } 
} 

Это продемонстрирует ковариации , Кроме того, вы можете сохранить его в качестве параметров, но переключать типы вокруг:

public delegate void MyDelegate(SomeObject obj) 

public class MyClass 
{ 
    public MyClass() 
    { 
     _delegate = MyMethod; 
    } 

    private MyDelegate _delegate; 

    public void MyMethod(object obj) {} 
} 

Теперь это демонстрирует контравариации.

Мое правило - спросить себя: «Если я даю делегат, что я могу с ним сделать? Если я могу передать аргумент, который нарушит метод, преобразование должно быть неудачным. Если метод может вернуть что-то который сломал бы вызывающего абонента , преобразование должно было завершиться неудачей ».

В вашем коде, вы могли бы назвать:

_delegate(new object()); 

В тот момент, бедный MyMethod имеет параметр, который является означает быть типа SomeObject, но на самом деле типа object. Это будет очень плохая вещь, поэтому компилятор перестает это делать.

Означает ли это, что все имеет смысл?

Answer 2

MyDelegate тип заявляет, что вы можете передать объект любого типа. Однако, MyMethod принимает только объекты типа SomeObject. Что произойдет, если я попытаюсь вызвать делегата, передающего объект другого типа: _delegate("a string object")? Согласно заявлению MyDelegate, это должно быть разрешено, но ваша функция MyMethod не может фактически получить строковый аргумент.

Answer 3

Вам необходимо использовать общий.

EDIT: Почему? Потому что, как отметил другой плакат , Object и SomeObject не приравниваются к тому же, что и объект может не быть SomeObject. Это целая точка точки Generics.

public delegate void MyDelegate<T>(T obj) 

public class MyClass 
{ 
    public MyClass() 
    { 
     _delegate = MyMethod; 
    } 

    private MyDelegate<SomeObject> _delegate; 

    public void MyMethod(SomeObject obj) 
    { 
    } 
} 

Answer 4

Аргументы контравариантен, возврат типов ковариантны. Если делегат должен был быть вызван с object, который не является экземпляром SomeObject, у вас будет ошибка ввода. С другой стороны, возврат SomeObject из процедуры, завернутой в делегат, который возвращает object, в порядке.

Answer 5

Из MSDN ссылке вы предоставили

ковариации позволяет способ иметь более производный тип возвращаемого, чем то, что определяется в делегатом. Контравариантность допускает метод с типами параметров, которые являются менее производными , чем в типе делегата.

Вы пытаетесь использовать более производный тип параметр, который не поддерживается (хотя .NET 4.0, вероятно, так как это выяснял много проблем ковариация/контравариации).

Answer 6

Ковариация и контравариантность - это понимание Принципа Наследования.

В обоих случаях ковариация и контравариантность, с. «передается», либо как возвращаемое значение, либо как аргумент метода делегата. То, что «проходит», должно быть «поймано» в сосуде. В C# - или программировании жаргона как такового - мы используем слово bucket для того, что я назвал емкостью. Иногда вам приходится возвращаться к другим словам, чтобы понять смысл обычно используемых слов жаргона.

В любом случае, если вы понимаете наследование, которое, скорее всего, будет читателем здесь, то единственное, на что нужно обратить внимание, это то, что сосуд, т.е. е. ведро, используемое для ловли, должно быть того же типа или менее производного типа, чем тот, который передается - это справедливо как для ковариации, так и для контравариантности.

Наследование говорит, что вы можете поймать птицу в ведерке животных, потому что птица - это животное. Поэтому, если параметр метода должен поймать птицу, вы можете поймать его в ведро животного (параметр типа животного), что тогда является контравариантностью. И если ваш метод, т. Е. Ваш делегат возвращает птицу, то «ведро» также может быть птицей типа или менее производным (родительского типа), то есть переменная, в которой вы улавливаете возвращаемое значение метода, должна быть тот же или менее производный тип, чем возвращаемое значение.

Просто переключите свое мышление, чтобы различать то, что передается, и то, что ловится, а затем вся сложность в отношении ковариации и контравариантности растворяется красиво. Тогда вы понимаете, что тот же принцип работает. Просто наследование не может быть нарушено, поскольку оно протекает только одним способом.

И компилятор настолько умен, что, когда вы бросаете ведро в более специализированный тип (опять же, и, если необходимо), тогда и только тогда вы получаете все специализированные методы, которые были добавлены в более производный класс. Это его красота. Так что это улов, бросок и использование того, что у вас есть, и, возможно, вам нужно.