सी #: विभिन्न प्रकार के साथ जेनेरिक कक्षाओं की एक सूची घोषित और उपयोग, कैसे?

Question

निम्नलिखित सामान्य वर्ग है कि या तो string, int, float, long प्रकार के रूप में होते हैं के बाद:

public class MyData<T> 
{ 
    private T _data; 

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

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

मैं कहाँ प्रत्येक आइटम अलग T की होगी MyData<T> की एक सूची प्राप्त करने के लिए कोशिश कर रहा हूँ।

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

जहां SomeMethod() के रूप में घोषित किया जाता है इस प्रकार है::

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

---

मैं सूची से कोई आइटम का उपयोग करें और निम्न कोड में के रूप में अपने मूल्य प्राप्त करने में सक्षम होना चाहता हूँ

अद्यतन:

SomeMethod() एक और स्तरीय वर्ग से है जिसका मेरा नियंत्रण नहीं है और SomeMethod(object) मौजूद नहीं है।

---

हालांकि, मुझे कंपाइलर को खुश करने का कोई तरीका नहीं दिख रहा है।

कोई सुझाव?

धन्यवाद।

Answer 1

प्रतिनिधि वास्तव में इस आसान बनाने में मदद कर सकते हैं, और अभी भी बातें प्रकार सुरक्षित बनाए:

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

गैर-जेनेरिक MyData कक्षा से इनरिट MyData<T> और इसकी एक सूची बनाएं।

इस तरह, आप अधिभार को स्वचालित रूप से हल नहीं कर सकते हैं। आपको इसे मैन्युअल रूप से करना है।

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

उस मामले में आप MyData<object> की जरूरत के बाद से है कि केवल एक चीज उन प्रकार के आम में है है।