लुकअप () और डिक्शनरी (सूची का) के बीच अंतर

Question

मैं अपना सिर लपेटने की कोशिश कर रहा हूं जिसके आसपास डेटा संरचनाएं सबसे कुशल हैं और कब / कहां उपयोग करना है।

अब, यह हो सकता है कि मैं बस संरचनाओं को अच्छी तरह से समझ नहीं पा रहा हूं, लेकिन कैसे एक से ILookup(of key, ...)अलग है Dictionary(of key, list(of ...))?

इसके अलावा, मैं कहाँ उपयोग करना चाहता हूँ ILookupऔर कहाँ यह कार्यक्रम की गति / स्मृति / डेटा का उपयोग, आदि के संदर्भ में अधिक कुशल होगा?

Comments

कोई यह भी देखना चाहता है कि बिंदु-का-रूप-दृश्य क्या है

— nawfal

Answer 1

दो महत्वपूर्ण अंतर:

• Lookupअपरिवर्तनीय है। यय :) (कम से कम, मेरा मानना ​​है कि ठोस Lookupवर्ग अपरिवर्तनीय है, और ILookupइंटरफ़ेस कोई भी परिवर्तनशील सदस्य प्रदान नहीं करता है । निश्चित रूप से अन्य परिवर्तनशील कार्यान्वयन हो सकते हैं।)
• जब आप एक कुंजी खोजते हैं जो लुकअप में मौजूद नहीं है, तो आपको एक के बजाय एक खाली अनुक्रम वापस मिलता है KeyNotFoundException। (इसलिए वहाँ कोई नहीं है TryGetValue, AFAICR।)

वे दक्षता में समकक्ष होने की संभावना रखते हैं - Dictionary<TKey, GroupingImplementation<TValue>>उदाहरण के लिए लुकअप अच्छी तरह से पर्दे के पीछे का उपयोग कर सकता है । अपनी आवश्यकताओं के आधार पर उनके बीच चयन करें। व्यक्तिगत रूप से मुझे लगता है कि आम तौर पर लुकअप एक से बेहतर फिट हैDictionary<TKey, List<TValue>> , जो कि पहले दो बिंदुओं के कारण होता है।

ध्यान दें कि एक कार्यान्वयन विस्तार के रूप में, के ठोस कार्यान्वयन IGrouping<,>जो मान लागू करने के लिए प्रयोग किया जाता है IList<TValue>, जिसका अर्थ है कि इसके साथ उपयोग करने के लिए सक्षम है Count(), ElementAt()आदि

Comments

यदि कोई अपवाद के बजाय कोई भी महत्वपूर्ण कुंजी लुकअप नहीं करता है, तो सामान्य प्रयोजन संग्रह imo के रूप में इसका बहुत अधिक उपयोग नहीं किया जा सकता है। यह एक अपरिवर्तनीय संग्रह के मामले में थोड़े ठीक है जो कि लिन्क प्रश्नों का उपोत्पाद है।

— नवफाल

@nawfal - यह वही है जो लुकअप के लिए है। से MSDN : "आप एक वस्तु है कि लागू IEnumerable <टी> पर ToLookup को फोन करके एक लुक <TKey, Telement> का एक उदाहरण बना सकते हैं।"

— Niall Connaughton

Answer 2

दिलचस्प है कि किसी ने भी वास्तविक सबसे बड़ा अंतर नहीं बताया है ( MSDN से सीधे लिया गया ):

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

Comments

प्रश्न की जाँच करें: यह लुकअप <TKey, TValue> और एक शब्दकोश <TKey, सूची <TValue >> के बीच अंतर के बारे में है, ताकि अंतर पहले से ही स्पष्ट हो।

— मार्टो

@Martao कुछ लोगों को लुक और डिक्शनरी के बीच के अंतर को समझने के लिए जब यह प्रश्न मिलता है। यह उत्तर वास्तव में उपयोगी है।

— जकुबिसज़ोन

Answer 3

दोनों एक Dictionary<Key, List<Value>>और Lookup<Key, Value>तार्किक रूप से एक समान तरीके से आयोजित डेटा को पकड़ सकते हैं और दोनों दक्षता के समान क्रम के हैं। मुख्य अंतर ए हैLookup अपरिवर्तनीय है: इसकी कोई Add()विधियाँ और कोई सार्वजनिक निर्माण नहीं है (और जैसा कि जॉन ने उल्लेख किया है कि आप बिना किसी अपवाद के एक गैर-मौजूद कुंजी को क्वेरी कर सकते हैं और समूह के भाग के रूप में कुंजी है)।

जैसा कि आप किसका उपयोग करते हैं, यह वास्तव में इस बात पर निर्भर करता है कि आप उनका उपयोग कैसे करना चाहते हैं। यदि आप कई मानों की कुंजी का मानचित्र बनाए रख रहे हैं, जिसे लगातार संशोधित किया जा रहा है, तो एDictionary<Key, List<Value>> संभवत: यह बेहतर है क्योंकि यह परिवर्तनशील है।

यदि, हालांकि, आपके पास डेटा का एक क्रम है और बस कुंजी द्वारा आयोजित डेटा का केवल-पढ़ने का दृश्य चाहते हैं, तो एक लुकअप निर्माण करना बहुत आसान है और आपको एक रीड-ओनली स्नैपशॉट देगा।

Answer 4

A ILookup<K,V>और a के बीच प्राथमिक अंतर Dictionary<K, List<V>>यह है कि एक शब्दकोश उत्परिवर्तनीय है; आप कुंजियाँ जोड़ या हटा सकते हैं, और उन वस्तुओं को भी जोड़ या हटा सकते हैं, जो ऊपर देखी गई हैं। एक ILookupहै अपरिवर्तनीय है और एक बार बनाया बदला नहीं जा सकता।

दोनों तंत्रों का अंतर्निहित कार्यान्वयन या तो समान या समान होगा, इसलिए उनकी खोज गति और स्मृति पदचिह्न लगभग समान होंगे।

Comments

@JohnBustos प्रदर्शन के मामले में, नहीं। यह विशुद्ध रूप से तार्किक है। आप संरचना के संदर्भ में किसी और के बारे में चिंता न करें और इसे अपने नीचे से संशोधित कर सकते हैं। आप इस तथ्य पर धारणा बना सकते हैं कि यह अपरिवर्तनीय है कि अगर आप इसे बदलने योग्य नहीं थे।

— सर्व

धन्यवाद, Servy, यह एक बहुत अच्छा बिंदु है जब आप अक्सर इतने सारे चर पास से गुजर रहे होते हैं - अक्सर कम से कम यह निश्चित है कि आप संशोधित नहीं किए जा सकते हैं। धन्यवाद!

— जॉन बस्टोस

@ जॉनहॉस्टोस ध्यान रखें कि विधि पैरामीटर को पारित करने का डिफ़ॉल्ट तरीका मूल्य से है, आपको स्पष्ट रूप से बायफ़र जोड़ने की आवश्यकता है, और यह कुछ ऐसा है जिसे बहुत कम ही किया जाना चाहिए। ये डेटा संरचनाएं कक्षाएं हैं, जो उन्हें संदर्भ प्रकार बनाती हैं, इसलिए मान को पास करना संदर्भ का मूल्य है, यही कारण है कि इसे किसी अन्य विधि से पारित करने से कॉलर में दृश्यमान परिवर्तन हो सकते हैं।

— 14

धन्यवाद, Servy, जो मेरे लिए कीड़े की एक पूरी नई इच्छा को खोलता है, जो मैं कर रहा हूं :), लेकिन मुझे समझ में नहीं आता कि हम क्या कह रहे हैं। धन्यवाद!!

— जॉन बस्टोस

कवर के तहत क्या आपको पता है कि लुकअप कुंजी के लिए हैशबकेट का उपयोग करता है?

— पपराज़ो

Answer 5

एक और अंतर जो अभी तक उल्लेख नहीं किया गया है वह है लुकअप () अशक्त कुंजियों का समर्थन करता है :

लुकअप क्लास ILookup इंटरफ़ेस को लागू करता है। लुकअप एक शब्दकोश के समान है, जिसमें एक ही कुंजी को मैप करने के लिए कई मानों को अनुमति दी जाती है, और अशक्त कुंजियों का समर्थन किया जाता है।

Answer 6

जब अपवाद कोई विकल्प नहीं है, तो लुकअप के लिए जाएं

यदि आप एक संरचना के रूप में कुशल होने की कोशिश कर रहे हैं, Dictionaryलेकिन आप यह नहीं जानते कि इनपुट में कोई डुप्लिकेट कुंजी नहीं है, Lookupतो सुरक्षित है।

जैसा कि एक अन्य उत्तर में उल्लेख किया गया है, यह अशक्त कुंजियों का भी समर्थन करता है, और हमेशा एक वैध परिणाम देता है जब मनमाने ढंग से डेटा के साथ क्वेरी की जाती है, इसलिए यह अज्ञात इनपुट के लिए अधिक लचीला प्रतीत होता है (अपवादों को उठाने के लिए शब्दकोश की तुलना में कम प्रवण)।

और यह विशेष रूप से सच है यदि आप इसे System.Linq.Enumerable.ToDictionaryफ़ंक्शन से तुलना करते हैं:

// won't throw
new[] { 1, 1 }.ToLookup(x => x); 

// System.ArgumentException: An item with the same key has already been added.
new[] { 1, 1 }.ToDictionary(x => x);

विकल्प यह होगा कि आप foreachलूप के अंदर अपना डुप्लिकेट कुंजी प्रबंधन कोड लिखें ।

प्रदर्शन विचार, शब्दकोश: एक स्पष्ट विजेता

यदि आपको सूची की आवश्यकता नहीं है और आप बड़ी संख्या में आइटम का प्रबंधन करने जा रहे हैं, Dictionary(या यहां तक ​​कि आपकी खुद की कस्टम अनुरूप संरचना) अधिक उपयोगी होगी:

        Stopwatch stopwatch = new Stopwatch();
        var list = new List<string>();
        for (int i = 0; i < 5000000; ++i)
        {
            list.Add(i.ToString());
        }
        stopwatch.Start();
        var lookup = list.ToLookup(x => x);
        stopwatch.Stop();
        Console.WriteLine("Creation: " + stopwatch.Elapsed);

        // ... Same but for ToDictionary
        var lookup = list.ToDictionary(x => x);
        // ...

जैसा कि Lookupप्रत्येक कुंजी के लिए वस्तुओं की एक सूची को बनाए रखना है, यह डिक्शनरी की तुलना में धीमा है (बड़ी संख्या में मदों के लिए लगभग 3x धीमा)

लुकअप गति: निर्माण: 00: 00: 01.5760444

शब्दकोश गति: निर्माण: 00: 00: 00.4418833