C＃の存在タイプ？

Question

私は現在、C＃の問題に直面しています。実在のタイプを使用して解決できると思います。しかし、私はC＃で作成できるのか、（他のいくつかの構造を使って）シミュレートされているのかどうかは分かりません。が、それが持っているどのような種類のパラメータ気にせず

public interface MyInterface<T> 
{ 
    T GetSomething(); 
    void DoSomething(T something); 
} 

public class MyIntClass : MyInterface<int> 
{ 
    int GetSomething() 
    { 
     return 42; 
    } 

    void DoSomething(int something) 
    { 
     Console.Write(something); 
    } 
} 

public class MyStringClass : MyInterface<string> 
{ 
    string GetSomething() 
    { 
     return "Something"; 
    } 

    void DoSomething(string something) 
    { 
     SomeStaticClass.DoSomethingWithString(something); 
    } 
} 

次の私は、このインターフェイスを実装するオブジェクトのリストを反復することができるようにしたい：

は基本的に私はこのようないくつかのコードを持っていると思います。このような何か：

public static void DoALotOfThingsTwice(){ 
    var listOfThings = new List<MyInterface<T>>(){ 
     new MyIntClass(), 
     new MyStringClass(); 
    }; 

    foreach (MyInterface<T> thingDoer in listOfThings){ 
     T something = thingDoer.GetSomething(); 
     thingDoer.DoSomething(something); 
     thingDoer.DoSomething(something); 
    } 
} 

MyIntClassで使用TとMyStringClassで使用されるものが異なるので、これはコンパイルされません。

私はこのような何かがトリックを行うことができると考えていたが、C＃でそうする有効な方法があるかどうかはわからない：

public static void DoALotOfThingsTwice(){ 
    var listOfThings = new List<∃T.MyInterface<T>>(){ 
     new MyIntClass(), 
     new MyStringClass(); 
    }; 

    foreach (∃T.MyInterface<T> thingDoer in listOfThings){ 
     T something = thingDoer.GetSomething(); 
     thingDoer.DoSomething(something); 
     thingDoer.DoSomething(something); 
    } 
} 

Answer 1

DoALotOfThingsTwiceはTには依存しませんので、Actionにラップして、代わりにリストに保存してください。

public static Action DoSomethingTwice<T>(this MyInterface<T> i) 
{ 
    return() => 
    { 
     T something = i.GetSomething(); 
     i.DoSomething(something); 
     i.DoSomething(something); 
    }; 
} 

その後、

var listOfThings = new List<Action>() { 
    new MyIntClass().DoSomethingTwice(), 
    new MyStringClass().DoSomethingTwice() 
}; 

Answer 2

ない可能性を直接C＃で。

あなたは型の安全性をドロップし、非ジェネリックベースのインタフェースを持っており、「汎用」のコードのためにそれを使用することができ、次のいずれか

public interface MyInterface 
{ 
    object GetSomething(); 
    void DoSomething(object something); 
} 

public interface MyInterface<T> : MyInterface 
{ 
    T GetSomething(); 
    void DoSomething(T something); 
} 

またはdynamicを使用する（再びなしコンパイル時の型の安全性）：

foreach (dynamic thingDoer in listOfThings) 
{ 
    dynamic something = thingDoer.GetSomething(); 
    thingDoer.DoSomething(something); 
    thingDoer.DoSomething(something); 
} 

ハンドラの複数のバージョンを生成し、タイプ（How do I use reflection to call a generic method?）に基づいて（キャッシュ付きで）作成する（注：List<object>またはList<NonGenericBaseInterface>またはよりも「任意のオブジェクトのリスト」を実際に表現することはできません）：

同様に、表現ツリーを使用して同様のコードを作成することもできます。

Answer 3

私は防弾ソリューションを提供することはできません、あなたの実際のドメインであなたの根本的な問題だかわからないので。 what's covariance and contravariance in generic parameters both on interfaces and delegatesを見て、このアプローチでコードをリファクタリングしてみる価値があります。今の

、私はこれが可能な解決策であることを信じる：

public static void DoALotOfThingsTwice() 
{ 
    var listOfThings = new List<object> 
    { 
     new MyIntClass(), new MyStringClass() 
    }; 

    MyInterface<int> a; 
    MyInterface<string> b; 

    // During each iteration, check if the thing is a concrete 
    // implementation of your interface MyInterface<T>... 
    foreach (object thingDoer in listOfThings) 
    {   
     // ...and call MyInterface<T>.DoSomething method depending on 
     // the success of the cast to MyInterface<int> or 
     // MyInterface<string> 
     if ((a = thingDoer as MyInterface<int>) != null) 
      a.DoSomething(38); 
     else if((b = thingDoer as MyInterface<string>) != null) 
      b.DoSomething("hello world"); 
    } 
}