c# - लुकअप<टीके, टेलीमेंट> का मुद्दा क्या है?




.net linq (4)

एमएसडीएन इस तरह लुकअप बताता है:

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

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


इसके बारे में सोचने का एक तरीका यह है: Lookup<TKey, TElement> Dictionary<TKey, Collection<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());
        }
    }
}

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

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

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


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

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

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 उपयोग करता हूं।)


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");

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

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





lookup