लुकअप <TKey, Telement> का क्या मतलब है?

Question

MSDN लुकअप को इस तरह समझाता है:

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

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

Answer 1

यह एक 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से इनमें से अधिकांश घोषणाओं के लिए उपयोग करूंगा ।)

Comments

मुझे लगता है कि इस उत्तर को बेहतर बनाने के लिए आप कुछ संस्करणों को बदल सकते हैं। सीखने के उद्देश्यों के लिए मुझे लगता है कि इसका पालन करना आसान है, जब प्रकार स्पष्ट रूप से व्यक्त किए जाते हैं। बस मेरे 2 सेंट :)

— एलेक्स बारानोस्की

यदि यह दोनों दुनिया में सबसे अच्छा है, तो एक शब्दकोश के साथ परेशान क्यों है?

— काइल बरन

@ केलीबरन: क्योंकि यह वास्तविक कुंजी / मूल्य जोड़ी संग्रह के लिए व्यर्थ होगा, जहाँ प्रति कुंजी केवल एक मूल्य है।

— जॉन स्कीट

@KyleBaran Lookup<,>बस एक अपरिवर्तनीय संग्रह है ( Addउदाहरण के लिए कोई विधि नहीं है ) जिसका सीमित उपयोग है। इसके अलावा, इस अर्थ में एक सामान्य उद्देश्य संग्रह नहीं है कि यदि आप एक गैर-कुंजी की खोज करते हैं, तो आपको अपवाद के बजाय एक खाली अनुक्रम मिलता है, जो कि केवल विशेष संदर्भों में सार्थक है, उदाहरण के लिए, linq के साथ। यह इस तथ्य के साथ अच्छी तरह से चला जाता है कि एमएस ने वर्ग के लिए एक सार्वजनिक निर्माता प्रदान नहीं किया है।

— नवाफाल

उत्तर पढ़ने के आदेश है jwg -> bobbymcr -> jonskeet

— snr

Answer 2

इसके बारे में सोचने का एक तरीका यह है: 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()); // 1
            Console.WriteLine("S's: {0}", namesByInitial['S'].Count()); // 2
            Console.WriteLine("Z's: {0}", namesByInitial['Z'].Count()); // 0, does not throw
        }
    }
}

Comments

क्या लुकअप परिणाम में शून्य तत्व हो सकते हैं? आप इसे कैसे प्राप्त करेंगे? (लुकअप सार्वजनिक रूप से अपरिवर्तनीय है जहाँ तक मैं बता सकता हूँ, और मुझे नहीं लगता कि टोलकुप प्रभावी रूप से कुंजियों का आविष्कार करेगा।)

— जॉन स्कीट

तकनीकी रूप से, हां, चूंकि लुकअप एक गैर-मौजूद कुंजी के लिए एक खाली संग्रह देता है (मैंने एक कोड नमूना जोड़ने के लिए अपनी पोस्ट को संपादित किया जो यह दिखाता है)।

— bobbymcr

उत्तर पढ़ने के आदेश है jwg -> bobbymcr -> jonskeet

— snr

एक बहुत ही साफ और मददगार जवाब, मेरी इच्छा है कि इसे चुना गया।

— मिनट

Answer 3

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

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

अब आप यह देखना चाहते हैं कि किसी दिए गए फोन नंबर का कौन है। आप अपने से Lookupसभी को जोड़ते हुए एक का निर्माण KeyValuePairsकरते हैं Dictionary, लेकिन पीछे की ओर, मूल्य के रूप में कुंजी और कुंजी के रूप में मूल्य के साथ। अब आप एक फ़ोन नंबर को क्वेरी कर सकते हैं, और उन सभी लोगों के नामों की सूची प्राप्त कर सकते हैं, जिनका फ़ोन नंबर है। एक 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।

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

Comments

अवधारणा को समझने के लिए उत्तर महत्वपूर्ण है। +1। उत्तर पढ़ने के क्रम में jwg -> bobbymcr -> jonskeet

— snr

Answer 4

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

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

Answer 5

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

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

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

Comments

आपके उत्तर ने मेरे अनुवर्ती प्रश्न को प्रेरित किया "हाउ टू लुकअप () मल्टीपल इंडेक्स के साथ?" । मैं कई अनुक्रमित, लुकअप के साथ ऐसे कैसे पुन: पेश कर सकता हूं? क्या आप इसका उत्तर संभवतः किसी अन्य नमूने या संदर्भ का उपयोग करके दे सकते हैं जहां इसका उपयोग करना संभव है Lookup["Smith"]["John"] ?

— फुलप्रूफ