जेनेरिक सूचियों या विभिन्न प्रकारों के शब्दकोश

Question

मैं एक शब्दकोश चाहता हूं जो अलग-अलग प्रकार की जेनेरिक सूचियों के तारों को मानचित्रित करे।

Type layerType = pair.Value.GetType().GetGenericArguments()[0]; 
List<layerType> objectsClicked = pair.Value as List<layerType>; 

वहाँ है यह करने के लिए एक अच्छा तरीका है: निम्नलिखित रूप में अर्थात्: इस प्रकार

 
Key  Value 
string  List<T> 
string  List<U> 
string  List<V> 
string  List<U> 
... 

वर्तमान में मैं एक Dictionary<string, IList> उपयोग कर रहा हूँ और उसके बाद प्रत्येक शब्दकोश KeyValuePair<string, IList> pair प्रवेश के समय से ही टाइप किया सूची निकाली गई ?

[संपादित करें] जैसा कि देखा गया है, उपर्युक्त संकलन नहीं करता है, माफ़ी माँगता है - जब आप किसी प्रश्न पूछते हैं तो आप यही करते हैं, जबकि आप अभी भी कुछ काम कर रहे हैं। कुछ और स्पष्टीकरण। मैं एक मूल स्थानिक डेटा दर्शक बना रहा हूं। अंतिम दृश्य में Layer<T> एस का समूह शामिल है। प्रत्येक परत अपने प्रकार को प्रस्तुत करने के लिए एक प्रतिनिधि प्रदान करती है (ऑफ़सेट और स्केल दिया जाता है) और यह जांचने का एक तरीका है कि इसकी कौन सी ऑब्जेक्ट वर्तमान विंडो में हैं। हिट परीक्षण के लिए, मैं प्रत्येक परत के लिए एक सूची चाहूंगा जिसमें से वस्तुओं को मारा गया है। Point परत, आदि के लिए यह सूची List<Point> होगी ... सभी Layer<T> एस से हिट का समूहकरण दृढ़ता से टाइप की गई सूचियों का संग्रह होगा।

Answer 1

कैसे के बारे में Dictionary<string, dynamic> मानते हुए कि आपके सी # पर हैं 4

Dictionary<string, dynamic> Dict = new Dictionary<string, dynamic>(); 
Dict.Add("int", new List<int>()); 
Dict.Add("string", new List<string>()); 

Dict["int"].Add(12); 
Dict["string"].Add("str"); 

foreach (KeyValuePair<string, dynamic> pair in Dict) { 
    Type T = pair.Value.GetType(); 
    Console.WriteLine(T.GetGenericArguments()[0].ToString()); 
} 

बाहर प्रिंट कि

System.Int32

System.String

कि है कि तुम क्या खोज रहे हैं?

Answer 2

Dictionary<string, IList> का उपयोग संभवतः केवल समाधान है। लेकिन कोड का आपका टुकड़ा गलत है, आप इस तरह जेनरिक का उपयोग नहीं कर सकते हैं। आप इस प्रकार प्रकार गतिशीलता बना सकते हैं।

आपकी आवश्यकता के साथ सामान्य समस्या यह है कि यह मजबूत टाइप की गई भाषा जैसे सी # के अनुकूल नहीं है। मजबूत टाइप की गई भाषा में आपको पता होना चाहिए कि किस प्रकार का प्रकार बिल्कुल सही है। लेकिन सामान्य साधनों का उपयोग करके किया जा सकता है। जेनेरिक की आपकी समझ भी गलत है। इस प्रकार का एकमात्र संकलन-समय विस्तार।

और सामान्य विचार: आपके मामले में, उन सूचियों में सहेजे गए प्रकारों के किसी प्रकार की ओओपी हाइर्चरी का उपयोग करके। यह बहुत बेहतर और सुरक्षित विचार होगा और आपके कोड को देखे जाने वाले हर किसी को अपने बालों को चीर नहीं देगा।

Answer 3

मैं जश्न और एडम के बीच एक Middleground लेने के लिए जा रहा हूँ, आप IList और dynamic दोनों का उपयोग करना चाहिए। यही वह है जो मुझे लगता है कि यह अधिक सही है:

var dict = new Dictionary<string, IList>(); 
dict.Add("u", new List<U>()); 
dict.Add("v", new List<V>()); 

// in case of members you know they exist on an IList 
dict["u"].Add(new U()); 
dict["v"].Add(new V()); 

// in case you know what you are going to get back, in which case you should cast 
var uProperty = (dict["u"][0] as U).UProperty 
var vProperty = (dict["v"][0] as V).VProperty 

// in case your're not sure of  
(dict[someKey] as dynamic)[someIndex].SomeMember...; 

ये सभी प्रतिबिंब पर निर्भर होने से कहीं अधिक सरल हैं। प्रतिबिंब monstrosity को कम करने और कोड कम करने के लिए dynamic का उपयोग करते समय, अपने इरादे को स्पष्ट करने के लिए, मूल विचार को IList के रूप में शब्दकोश मान प्रकार घोषित करें।

Answer 4

मैं वास्तव में लगता है कि क्लीनर दृष्टिकोण अपने शब्दकोश के लिए एक आवरण बनाने के लिए है:

public class GlobalStore 
{ 
    private readonly IDictionary<Type, IEnumerable> _globalStore; 

    public GlobalStore() 
    { 
     _globalStore = new ConcurrentDictionary<Type, IEnumerable>(); 
    } 

    public IEnumerable<T> GetFromCache<T>() 
     where T : class 
    { 
     return (IEnumerable<T>) _globalStore[typeof(T)]; 
    } 

    public void SetCache<T>(IEnumerable<T> cache) 
     where T : class 
    { 
     _globalStore[typeof(T)] = cache; 
    } 
} 

यहाँ यह के लिए एक परीक्षण है:

[TestClass] 
public class GlobalStoreTest 
{ 
    [TestMethod] 
    public void GlobalStore_Test() 
    { 
     //Arrange 
     var globalStore = new GlobalStore(); 
     globalStore.SetCache(new List<ClientModel> 
     { 
      new ClientModel 
      { 
       ClientId = 1, 
       ClientName = "Client1" 
      }, 
      new ClientModel 
      { 
       ClientId = 2, 
       ClientName = "Client2" 
      } 
     }); 

     //Act 
     var clients = globalStore.GetFromCache<ClientModel>(); 

     //Assert 
     Assert.AreEqual(2, clients.Count()); 
    } 
}