一般的な制約が期待どおりに動作しません

Question

私は理解し、いくつかの問題を抱えています次のスニペットは、私にエラー

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

しかし、私は一般的なのために働くことを期待する、このいずれかを、与えていない理由型制約

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

public IDisposable Subscribe<T>(Action<T> callback) where T: MyInterface 
{ 
    myActionList.Add(callback); // doesn't compile 
    return null 
} 

は、私はVS2012 SP1と.NET 4.5を使用しています。このエラーに

cannot convert from 'System.Action<T>' to 'System.Action<MyInterface>' 

を与えます。

誰かが制約によってこれをコンパイルできない理由を説明できますか？

Answer 1

クラスとデリゲートは同じではありません。 System.Action<MyInterface>は、タイプがMyInterfaceの単一のパラメータを持つ関数を表し、System.Action<T>は、タイプがT : MyInterfaceのメソッドを表す関数を表します。関数の署名は互換性がなく、の派生語はMyInterfaceではなく、Tが正確にMyInterfaceの場合にのみ署名が互換性があります。

Answer 2

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 
} 

が動作し、コンパイルして、実質的にあなたが今持っているものと同じであるだろう。

ジェネリックはジェネリックの目的を破ったインターフェースにタイプを限定し、代わりにそのインターフェースを使用するだけでよい場合は、タイプにかかわらず同じ操作をしたい場合に便利です。しかし、あなたはTは安全ではありませんMyInterfaceのいくつかのサブタイプで、あるAction<T>を保存しようとしている、Action<MyInterface>は、引数として任意のMyInterfaceインスタンスを取ることができるはず -

Answer 3

これはcontravarianceの問題です。例えば

あなたが持っていた場合：タイプTがタイプUより「小さい」の場合

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<U>にAction<T>を割り当てることができます。たとえば、オブジェクト引数が常に文字列引数が有効なので、たとえば

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

は安全です。

Answer 4

where T: MyInterface制約は「の任意インスタンスMyInterfaceを実装するクラスまたは構造体」を意味します。

だから何あなたがやろうとしているが、このように単純化することができます。まだIList : IEnumerableながら、動作するようになっていません

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

。詳細はここで見つけることができます：

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; 
} 

Answer 5

クラスとデリゲートの動作が少し異なります。簡単な例を見てみましょう：この方法では

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

あなたは引数が常にMyInterfaceにキャストする可能性があるため、あなたがこのMyInterface e = arg;ような何かを行うことができますので、Tは、少なくともMyInterfaceだろうと想定できます。今

のは、代表者がどのように動作するかを見てみましょう：ので、

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

しかし、あなたはそれを行うことはできません。myActionListへ

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; 
} 

今we'rが追加DerivedClassコールバックして、どこかにあなたがデリゲートを呼び出しますDerivedClassコールバックがあれば、パラメータとしてDerivedClassを渡す必要があります。

この質問はCovariance and contravarianceを参照しています。あなたはthisの記事から分散について読むことができます。また、Eric Lippertは分散に関する記事を非常に織り込んでいます。thisが最初の記事です。彼のブログで残りを見つけることができます。

P.S.リーコメントへの編集。

Answer 6

このような状況では、動作を許可すると何が問題になるかを検討することが役立ちます。それでは、それを考えましょう。

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>への変換です。だから違法です。