Общее ограничение для действия не работает должным образом

Классы и делегаты — это не одно и то же. System.Action<MyInterface> представляет функцию с одним параметром типа MyInterface, а System.Action<T> представляет метод с параметром типа T : MyInterface. Сигнатуры функций несовместимы, не имеет значения, что T является производным от MyInterface, сигнатура будет совместима только в том случае, если T будет точно MyInterface.

Это проблема контравариантности - Action<MyInterface> должен иметь возможность принимать любой экземпляр MyInterface в качестве аргумента, однако вы пытаетесь сохранить Action<T>, где T является подтипом MyInterface, что небезопасно.

Например, если у вас было:

public class SomeImpl : MyInterface { }
public class SomeOtherImpl : MyInterface { }
List<Action<MyInterface>> list;

list.Add(new Action<SomeImpl>(i => { }));
ActionMyInterface act = list[0];
act(new SomeOtherImpl());

Вы можете присвоить Action<T> некоторым Action<U> только в том случае, если тип T "меньше", чем тип U. Например

Action<string> act = new Action<object>(o => { });

безопасен, поскольку строковый аргумент всегда действителен там, где находится объектный аргумент.

Ограничение where T: MyInterface означает "любой экземпляр любого класса или структуры, который реализует MyInterface".

Итак, то, что вы пытаетесь сделать, можно упростить следующим образом:

Action<IList> listAction = null;
Action<IEnumerable> enumAction = listAction;

Который не должен работать, пока еще IList : IEnumerable. Более подробную информацию можно найти здесь:

http://blogs.msdn.com/b/csharpfaq/archive/2010/02/16/covariance-and-contravariance-faq.aspx http://msdn.microsoft.com/en-us/library/dd799517.aspx

Поэтому, если вам действительно нужно использовать общий, а не только интерфейс, вы можете сделать это так, хотя это добавляет сложности и незначительные проблемы с производительностью:

public static IDisposable Subscribe<T>(Action<T> callback) where T : MyInterface
{
    myActionList.Add(t => callback((T)t)); // this compiles and work
    return null;
}

Я считаю полезным в таких ситуациях подумать, что пойдет не так, если вы позволите такое поведение. Итак, давайте рассмотрим это.

interface IAnimal { void Eat(); }
class Tiger : IAnimal 
{ 
  public void Eat() { ... }
  public void Pounce() { ... } 
}
class Giraffe : IAnimal 
...
public void Subscribe<T>(Action<T> callback) where T: IAnimal
{
   Action<IAnimal> myAction = callback; // doesn't compile but pretend it does.
   myAction(new Giraffe()); // Obviously legal; Giraffe implements IAnimal
}
...
Subscribe<Tiger>((Tiger t)=>{ t.Pounce(); });

Так что же происходит? Мы создаем делегата, который берет тигра и набрасывается, передаем его Subscribe<Tiger>, преобразуем его в Action<IAnimal> и передаем жирафа, который затем набрасывается.

Понятно, что это должно быть незаконно. Единственное место, где разумно сделать его незаконным, — это преобразование из Action<Tiger> в Action<IAnimal>. Так вот где это незаконно.

Классы и делегаты ведут себя немного иначе. Давайте посмотрим на простой пример:

public void SomeMethod<T>(T arg) where T : MyInterface
{
  MyInterface e = arg;
}

В этом методе вы можете предположить, что T будет по крайней мере MyInterface, поэтому вы можете сделать что-то вроде этого MyInterface e = arg;, потому что аргументы всегда могут быть приведены к MyInterface.

Теперь давайте посмотрим, как ведут себя делегаты:

public class BaseClass { };
public class DerivedClass : BaseClass { };
private readonly IList<Action<BaseClass >> myActionList = new List<Action<BaseClass>>();

public void Subscribe<T>(Action<T> callback) where T: BaseClass
{
  myActionList.Add(callback); // so you could add more 'derived' callback here Action<DerivedClass>
  return null;
}

Теперь мы добавляем обратный вызов DerivedClass в myActionList, а затем где-то вы вызываете делегатов:

foreach( var action in myActionList ) {
   action(new BaseClass);
}

Но вы не можете этого сделать, потому что если у вас есть обратный вызов DerivedClass, вы должны передать его DerivedClass в качестве параметра.

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

P.S. Отредактировано в соответствии с комментарием Ли.

Если T в любом случае ограничен определенным интерфейсом, вы можете просто использовать этот интерфейс вместо него:

public void SomeMethod(MyInterface arg)
{
  MyInterface e = arg;
}

private readonly IList<Action<MyInterface>> myActionList = new IList<Action<MyInterface>>();

public IDisposable Subscribe(Action<MyInterface> callback)
{
  myActionList.Add(callback); // does compile
  return null
}

Будет работать и компилироваться и будет практически таким же, как у вас сейчас.

Дженерики полезны, если вы хотите выполнить одну и ту же операцию НЕЗАВИСИМО от типа, если вы затем ограничите тип некоторым интерфейсом, вы победили цель дженериков и, вероятно, должны вместо этого просто использовать этот интерфейс.