क्या मेरे पास यह सामान्य [] संपत्ति हो सकती है?

Question

मेरे पास एक DICOM शब्दकोश है जिसमें डेटा एलीमेंट से प्राप्त ऑब्जेक्ट्स का एक सेट होता है। शब्दकोश में एक कुंजी के रूप में int है, और DataElement संपत्ति के रूप में है।

public class DicomDictionary 
{ 
    Dictionary<int, DataElement> myElements = new Dictionary<int, DataElement>(); 
    . 
    . 
    public DataElement this[int DataElementTag] 
    { 
    get 
    { 
     return myElements[int]; 
    } 
    } 
} 

अब एक समस्या यह है कि मैं अलग DataElement प्रकार सभी DataElementSQ, DataElementOB तरह DataElement से पाने, और इतने पर है: मेरे DICOM शब्दकोश एक इस [] संपत्ति जहां मैं DataElement उपयोग कर सकते हैं, इस तरह होता है।

public T this<T>[int DataElementTag] where T : DataElement 
{ 
    get 
    { 
     return myElements[int]; 
    } 
} 

लेकिन यह वास्तव में संभव नहीं है: क्या मैं अब करना चाहता था सी # एक छोटा सा आसान में लेखन बनाने के लिए निम्नलिखित है। क्या मुझे कुछ याद आया है? बेशक मैं इसे गेटटर विधि के साथ कर सकता हूं, लेकिन यह इस तरह से होना बहुत अच्छा होगा।

Answer 1

इसके बजाय असली जेनेरिक विधि GetDataElement<T> where T : DataElement का उपयोग क्यों नहीं करें? जेनेरिक इंडेक्सर्स सी # में समर्थित नहीं हैं। आप इस मामले में क्यों सोचते हैं कि एक सूचकांक एक विधि से बेहतर है?

Answer 2

सबसे अच्छा विकल्प या तो एक सामान्य विधि (इंडेक्सर के बजाए) का उपयोग करना है, या अपनी कक्षा सामान्य होने के लिए है (इस मामले में, सूचकांक वर्ग जेनेरिक प्रकार से बंधेगा)। आपके द्वारा वर्णित एक जेनेरिक इंडेक्सर को सी # में अनुमति नहीं है।

Answer 3

क्या यह आपके लिए मामला है?

public class DicomDictionary<TElement> 
{ 
     Dictionary<int, TElement> myElements = new Dictionary<int, TElement>(); 
     public TElement this[int DataElementTag] 
     {  
       get  
       {  
       return myElements[int];  
       } 
     } 
} 

Answer 4

SLL जवाब के लिए संलग्न है:

public class Acessor<TKey, TValue> 
    where TKey : IComparable 
    where TValue : class 
{ 
    Dictionary<TKey, TValue> myElements = new Dictionary<TKey, TValue>(); 

    public TValue this[TKey key] 
    { 
     get 
     { 
      return myElements[key]; 
     } 
     set 
     { 
      myElements.Add(key, value); 
     } 
    } 
} 

या बिना कक्षा हस्ताक्षर बदलने के लिए:

public class Acessor 
{ 
    Dictionary<string, object> myElements = new Dictionary<string, object>(); 

    public object this[string key] 
    { 
     get 
     { 
      return myElements[key]; 
     } 
     set 
     { 
      myElements.Add(key, value); 
     } 
    } 
} 

और सामान्य प्रकार के लिए पार्स करने के लिए एक विधि बनाने के लिए:

public T Get<T>(string key) 
     where T : class 
    { 
     return (T)Convert.ChangeType(acessor[key], typeof(T)); 
    }