लुकअप <टीके, टेलीमेंट> का क्या मतलब है?

Question

MSDN इस तरह लुक बताते हैं:

एक Lookup<TKey, TElement> एक Dictionary<TKey, TValue> जैसा दिखता है। अंतर यह है कि एक शब्दकोश < TKey, TValue > एकल मूल्यों के लिए नक्शे चाबियाँ, जबकि एक लुक < TKey, Telement > मूल्यों का संग्रह करने के लिए नक्शे चाबियाँ।

मुझे यह स्पष्टीकरण विशेष रूप से सहायक नहीं लगता है। लुकअप के लिए क्या उपयोग किया जाता है?

Answer 1

यह IGrouping और एक शब्दकोश के बीच एक क्रॉस है। यह आपको एक कुंजी द्वारा वस्तुओं को एक साथ समूहबद्ध करने देता है, लेकिन फिर उस कुंजी के माध्यम से उन्हें कुशल तरीके से एक्सेस करें (केवल उन सभी पर पुनरावृत्ति करने के बजाय, जो GroupBy आपको करने देता है)।

उदाहरण के लिए, आप नेट प्रकार का भार ले सकता है और नाम स्थान से एक देखने का निर्माण ... तो बहुत आसानी से एक विशेष नाम स्थान में सभी प्रकार के लिए मिलता है:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Xml; 

public class Test 
{ 
    static void Main() 
    { 
     // Just types covering some different assemblies 
     Type[] sampleTypes = new[] { typeof(List<>), typeof(string), 
            typeof(Enumerable), typeof(XmlReader) }; 

     // All the types in those assemblies 
     IEnumerable<Type> allTypes = sampleTypes.Select(t => t.Assembly) 
               .SelectMany(a => a.GetTypes()); 

     // Grouped by namespace, but indexable 
     ILookup<string, Type> lookup = allTypes.ToLookup(t => t.Namespace); 

     foreach (Type type in lookup["System"]) 
     { 
      Console.WriteLine("{0}: {1}", 
           type.FullName, type.Assembly.GetName().Name); 
     } 
    } 
} 

(मैं सामान्य रूप से था । इन घोषणाओं के अधिकांश के लिए var का उपयोग, सामान्य कोड में)

Answer 2

मैं इसे सफलतापूर्वक से पहले उपयोग नहीं किया है, लेकिन यहाँ मेरे जाने है:

एक Lookup<TKey, TElement> एक (संबंधपरक) डेटाबेस पर सूचकांक की तरह काफी कैसा व्यवहार करेंगे बिना एक अद्वितीय के एक टेबल ई बाधा इसे उसी स्थान पर प्रयोग करें जहां आप दूसरे का उपयोग करेंगे।

Answer 3

इसके बारे में सोचने का एक तरीका यह है: Lookup<TKey, TElement>Dictionary<TKey, Collection<TElement>> के समान है। असल में शून्य या अधिक तत्वों की एक सूची उसी कुंजी के माध्यम से वापस की जा सकती है।

namespace LookupSample 
{ 
    using System; 
    using System.Collections.Generic; 
    using System.Linq; 

    class Program 
    { 
     static void Main(string[] args) 
     { 
      List<string> names = new List<string>(); 
      names.Add("Smith"); 
      names.Add("Stevenson"); 
      names.Add("Jones"); 

      ILookup<char, string> namesByInitial = names.ToLookup((n) => n[0]); 

      // count the names 
      Console.WriteLine("J's: {0}", namesByInitial['J'].Count()); 
      Console.WriteLine("S's: {0}", namesByInitial['S'].Count()); 
      Console.WriteLine("Z's: {0}", namesByInitial['Z'].Count()); 
     } 
    } 
} 

Answer 4

मुझे लगता है कि आप इस तरह से बहस कर सकते हैं: कल्पना करें कि आप एक फोन बुक की सामग्री को पकड़ने के लिए डेटा संरचना बना रहे हैं। आप lastName और फिर firstName द्वारा कुंजी करना चाहते हैं। यहां एक शब्दकोश का प्रयोग खतरनाक होगा क्योंकि बहुत से लोगों का नाम समान हो सकता है। तो एक शब्दकोश हमेशा, एक ही मूल्य पर नक्शा, हमेशा होगा।

एक लुकअप संभावित रूप से कई मूल्यों पर नक्शा रखेगा।

लुकअप ["स्मिथ"] ["जॉन"] आकार एक बिलियन का संग्रह होगा।

Answer 5

Lookup का एक उपयोग Dictionary को उलट सकता है।

मान लीजिए कि आपके पास Dictionary के रूप में लागू की गई एक फोनबुक है (चाबियाँ के रूप में अद्वितीय) नामों के साथ, प्रत्येक नाम एक फोन नंबर से जुड़ा हुआ है। लेकिन अलग-अलग नाम वाले दो लोग एक ही फोन नंबर साझा कर सकते हैं। यह Dictionary के लिए कोई समस्या नहीं है, जो इस बात की परवाह नहीं करता कि दो कुंजी एक ही मान के अनुरूप हैं।

अब आप यह देखने का एक तरीका चाहते हैं कि कोई दिया गया फ़ोन नंबर किसके पास है। आप Lookup बनाते हैं, जो आपके Dictionary से सभी KeyValuePairs जोड़ते हैं, लेकिन पीछे की ओर, मूल्य के साथ कुंजी और कुंजी के रूप में मान के साथ। अब आप एक फोन नंबर पूछ सकते हैं, और उन सभी लोगों के नामों की एक सूची प्राप्त कर सकते हैं जिनके फोन नंबर हैं।एक ही डेटा के साथ एक Dictionary बिल्डिंग डेटा छोड़ देगी, (या असफल पर आप इसे कैसे किया निर्भर करता है,)

dictionary["555-6593"] = "Dr. Emmett Brown"; 
dictionary["555-6593"] = "Marty McFly"; 

कर के बाद से इसका मतलब है कि दूसरी प्रविष्टि अधिलेखित कर देता है पहले - डॉक्टर नहीं रह गया है सूचीबद्ध है।

एक से थोड़ा अलग तरीके से एक ही डेटा लिखने के लिए कोशिश कर रहा है:

dictionary.Add("555-6593", "Dr. Emmett Brown"); 
dictionary.Add("555-6593", "Marty McFly"); 

दूसरी पंक्ति पर एक अपवाद फेंक के बाद से आप कर सकते हैं नहीं Add एक प्रमुख जो Dictionary में पहले से ही है।

[बेशक, आप दोनों दिशाओं में लुकअप करने के लिए कुछ अन्य एकल डेटा संरचना का उपयोग करना चाह सकते हैं। इस उदाहरण का अर्थ है कि आपको Dictionary से प्रत्येक बार बाद में परिवर्तनों को पुन: उत्पन्न करना होगा। लेकिन कुछ डेटा के लिए यह सही समाधान हो सकता है।]