Các loại tồn tại trong C#?

Question

Tôi hiện đang gặp sự cố trong C# mà tôi cho rằng có thể được giải quyết bằng các loại hiện có. Tuy nhiên, tôi không thực sự biết nếu họ có thể được tạo ra trong C#, hoặc mô phỏng (sử dụng một số cấu trúc khác).

Về cơ bản tôi muốn có một số mã như thế này:

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

Tiếp theo, tôi muốn để có thể lặp thông qua một danh sách các đối tượng mà thực hiện giao diện này, nhưng mà không quan tâm những gì tham số kiểu nó có. Một cái gì đó như thế này:

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

này không biên dịch vì T sử dụng bởi MyIntClass và được sử dụng bởi MyStringClass là khác nhau.

Tôi đã suy nghĩ rằng một cái gì đó như thế này có thể làm các trick, nhưng tôi không biết nếu có một cách hợp lệ để làm như vậy trong 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

Vì DoALotOfThingsTwice không phụ thuộc vào số T, bạn có thể bọc nó trong một số Action và lưu trữ những thứ đó trong danh sách thay thế, ví dụ:

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

sau đó

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

Answer 2

Không thể trực tiếp trong C#.

Bạn có thể an toàn kiểu thả và có giao diện cơ sở không chung chung và sử dụng nó cho mã "chung chung":

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

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

Hoặc sử dụng dynamic (một lần nữa không có thời gian biên dịch loại an toàn):

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

Hoặc tạo nhiều phiên bản của trình xử lý và tạo (có thể với bộ nhớ đệm) dựa trên loại (How do I use reflection to call a generic method?) (Lưu ý: bạn không thể thể hiện "danh sách các đối tượng tùy ý" tốt hơn List<object> hoặc List<NonGenericBaseInterface> hoặc List<NonGenericBaseClass>):

foreach (object thingDoer in listOfThings) 
{ 
    // get Do via reflection and create specific version based on 
    // thingDoer.GetType(), than invoke 
    // consider caching "methodForType" in Dictionary by type 
    MethodInfo method = this.GetType().GetMethod("Do"); 
    MethodInfo methodForType = method.MakeGenericMethod(thingDoer.GetType()); 
    methodForType.Invoke(thingDoer, null); 

} 

void Do<T>(MyInterface<T> thingDoer) 
{ 
    T something = thingDoer.GetSomething(); 
    thingDoer.DoSomething(something); 
    thingDoer.DoSomething(something); 
} 

Cách khác để phản ánh là sử dụng cây Biểu thức để tạo mã tương tự.

Answer 3

Vì tôi không biết vấn đề cơ bản của bạn trong phạm vi thực tế của bạn là những gì tôi không thể cung cấp một giải pháp chống đạn. Cần phải nỗ lực mà bạn nên xem xét về what's covariance and contravariance in generic parameters both on interfaces and delegates và cung cấp cho phương pháp tiếp cận này một lần thử tái cấu trúc mã của bạn.

Còn bây giờ, tôi tin rằng đây sẽ là một giải pháp khả thi:

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