C#: Khai báo và sử dụng danh sách các lớp chung với các kiểu khác nhau, làm thế nào?

Question

Có lớp học chung sau đó sẽ chứa hoặc string, int, float, long như các loại:

public class MyData<T> 
{ 
    private T _data; 

    public MyData (T value) 
    { 
     _data = value; 
    } 

    public T Data { get { return _data; } } 
} 

tôi đang cố gắng để có được một danh sách các MyData<T> nơi mỗi mục sẽ khác nhau T.

Tôi muốn để có thể truy cập vào một mục từ danh sách và nhận được giá trị của nó như trong đoạn mã sau:

MyData<> myData = _myList[0]; // Could be <string>, <int>, ... 
SomeMethod (myData.Data); 

nơi SomeMethod() được khai báo như sau:

public void SomeMethod (string value); 
public void SomeMethod (int value); 
public void SomeMethod (float value); 

---

CẬP NHẬT:

SomeMethod() là từ một cấp lớp khác mà tôi không có quyền kiểm soát và SomeMethod(object) không tồn tại.

---

Tuy nhiên, tôi dường như không thể tìm cách làm cho trình biên dịch hài lòng.

Mọi đề xuất?

Cảm ơn bạn.

Answer 1

Các đại biểu thực sự có thể giúp đơn giản hóa này, và vẫn giữ cho mọi thứ kiểu an:

public void TestMethod1() 
{ 
    Action<SomeClass, int> intInvoke = (o, data) => o.SomeMethod(data); 
    Action<SomeClass, string> stringInvoke = (o, data) => o.SomeMethod(data); 

    var list = new List<MyData> 
    { 
     new MyData<int> { Data = 10, OnTypedInvoke = intInvoke }, 
     new MyData<string> { Data = "abc", OnTypedInvoke = stringInvoke } 
    }; 

    var someClass = new SomeClass(); 
    foreach (var item in list) 
    { 
     item.OnInvoke(someClass); 
    } 
} 

public abstract class MyData 
{ 
    public Action<SomeClass> OnInvoke; 
} 

public class MyData<T> : MyData 
{ 
    public T Data { get; set; } 
    public Action<SomeClass, T> OnTypedInvoke 
    { set { OnInvoke = (o) => { value(o, Data); }; } } 
} 

public class SomeClass 
{ 
    public void SomeMethod(string data) 
    { 
     Console.WriteLine("string: {0}", data); 
    } 

    public void SomeMethod(int data) 
    { 
     Console.WriteLine("int: {0}", data); 
    } 
} 

Answer 2

Thừa kế MyData<T> từ lớp không chung chung MyData và tạo danh sách điều đó.

Bằng cách này, bạn không thể tự động giải quyết quá tải. Bạn phải làm điều đó bằng tay.

abstract class MyData { 
    protected abstract object GetData(); 
    protected abstract Type GetDataType(); 
    public object Data { 
     get { return GetData(); } 
    } 
    public Type DataType { 
     get { return GetDataType(); } 
    } 
} 

class MyData<T> : MyData { 
    protected override object GetData() { return Data; } 
    protected override Type GetDataType() { return typeof(T); } 
    public new T Data { 
    get { ... } 
    } 
} 

Answer 3

Trong trường hợp đó, bạn cần MyData<object> vì đó là điều duy nhất có những điểm chung.