प्रतिबिंब का उपयोग कर जेनेरिक सी # ऑब्जेक्ट को गतिशील रूप से कैसे बनाएं?

Question

सी # में मेरे पास निम्न ऑब्जेक्ट है:

public class Item 
{ } 

public class Task<T> 
{ } 

public class TaskA<T> : Task<T> 
{ } 

public class TaskB<T> : Task<T> 
{ } 

मैं सी # प्रतिबिंब ( Activator.CreateInstance) का उपयोग करके गतिशील रूप से टास्क या टास्कब बनाना चाहता हूं। हालांकि मैं हाथ से पहले के प्रकार को नहीं जानता, इसलिए मुझे "नेमस्पेस। टास्क" या "नेमस्पेस। टास्कैब" जैसे स्ट्रिंग के आधार पर गतिशील रूप से टास्क बनाने की आवश्यकता है।

Answer 1

यह article और यह simple example देखें। अपनी कक्षाओं के लिए एक ही के त्वरित अनुवाद ...

var d1 = typeof(Task<>); 
Type[] typeArgs = { typeof(Item) }; 
var makeme = d1.MakeGenericType(typeArgs); 
object o = Activator.CreateInstance(makeme); 

प्रति अपने संपादित: उस मामले के लिए, आप यह कर सकते हैं ...

var d1 = Type.GetType("GenericTest.TaskA`1"); // GenericTest was my namespace, add yours 
Type[] typeArgs = { typeof(Item) }; 
var makeme = d1.MakeGenericType(typeArgs); 
object o = Activator.CreateInstance(makeme); 

देखने के लिए जहाँ मैं नाम के लिए backtick1 के साथ आया था जेनेरिक वर्ग के, this article देखें।

नोट:

Type type = typeof(IReadOnlyDictionary<,>); 

Answer 2

मुझे ऐसा लगता है अपने उदाहरण कोड की अंतिम पंक्ति बस होना चाहिए: यदि आपका सामान्य वर्ग कई प्रकार के स्वीकार करता है, यदि आप कॉमा जब तुम प्रकार के नाम को छोड़ देते हैं, उदाहरण के लिए शामिल करना चाहिए :

Task<Item> itsMe = o as Task<Item>; 

या क्या मुझे कुछ याद आ रही है?

Answer 3

वास्तव में आप अंतिम पंक्ति लिखने में सक्षम नहीं होंगे।

लेकिन शायद आप इस उद्देश्य को बनाने या बनाने के लिए ऑब्जेक्ट बनाना नहीं चाहते हैं। आप शायद अपने नए बनाए गए उदाहरण पर कुछ विधि कॉल करना चाहते हैं।

फिर आप एक इंटरफेस की तरह कुछ की आवश्यकता होगी:

public interface ITask 
{ 
    void Process(object o); 
} 

public class Task<T> : ITask 
{ 
    void ITask.Process(object o) 
    { 
     if(o is T) // Just to be sure, and maybe throw an exception 
     Process(o as T); 
    } 

    public void Process(T o) { } 
} 

और से कॉल करने की:

Type d1 = Type.GetType("TaskA"); //or "TaskB" 
Type[] typeArgs = { typeof(Item) }; 
Type makeme = d1.MakeGenericType(typeArgs); 
ITask task = Activator.CreateInstance(makeme) as ITask; 

// This can be Item, or any type derived from Item 
task.Process(new Item()); 

किसी भी मामले में, आप स्थिर एक प्रकार आप डॉन 'में ढाला नहीं जा जाएगा पहले से पता नहीं (इस मामले में "makeme")। आईटस्क आपको अपने लक्षित प्रकार तक पहुंचने की अनुमति देता है।

यदि यह वही नहीं है जो आप चाहते हैं, तो आपको शायद इसके साथ हासिल करने की कोशिश में कुछ और विशिष्ट होना चाहिए।

Answer 4

सुनिश्चित करें कि आप इसे एक अच्छे कारण के लिए कर रहे हैं, निम्न जैसे एक साधारण कार्य स्थिर टाइपिंग की अनुमति देंगे और आपके आईडीई को "संदर्भ खोजें" और रिफैक्टर -> नाम बदलें।

public Task <T> factory (String name) 
{ 
    Task <T> result; 

    if (name.CompareTo ("A") == 0) 
    { 
    result = new TaskA(); 
    } 
    else if (name.CompareTo ("B") == 0) 
    { 
    result = new TaskB(); 
    } 

    return result; 
} 

Answer 5

मुझे पता है कि यह प्रश्न हल हो गया है, लेकिन इसे पढ़ने के किसी और के लाभ के लिए; आप तारों के रूप में शामिल किया प्रकार के सभी है, तो आप एक एक लाइनर के रूप में ऐसा कर सकता है:

IYourInterface o = (Activator.CreateInstance(Type.GetType("Namespace.TaskA`1[OtherNamespace.TypeParam]") as IYourInterface); 

जब भी मैं बात इस तरह का किया है, मैं एक अंतरफलक जो मैं का उपयोग करने के बाद कोड चाहते थे मिला है , इसलिए मैंने बनाया गया उदाहरण एक इंटरफेस में डाला है।