दिलचस्प पोस्ट
मिलिसेकंड को "hh: mm: ss" प्रारूप में कनवर्ट कैसे करें? सी ++ – enum बनाम const vs. #define प्रॉक्सी सर्वर और रिवर्स प्रॉक्सी सर्वर के बीच का अंतर एक स्थिर HTML पृष्ठ पर एक फ़ेविकॉन जोड़ना अप्रयुक्त जावास्क्रिप्ट फ़ंक्शंस खोजें? मैं डीजेंगो पोस्ट_एसएवी संकेत कोड के साथ परस्पर विरोधी से जुड़ने से कैसे रोक सकता हूं? कंसोल विंडो को प्रोसेस से प्रारंभ करें। प्रारंभ सी # एक आइफ्रेम पर कोणीय, ऑनलोड फ़ंक्शन एकाधिक पंक्तियों को एक अल्पविराम-पृथक मान एंड्रॉइड स्टूडियो अनुपलब्ध है ASP.NET MVC: क्या प्रत्येक अनुरोध के लिए नियंत्रक बनाया गया है? चर के लिए परिवर्तन श्रोता कैसे बनाएं? ResourceBundle के साथ संसाधन गुणों में यूटीएफ -8 का उपयोग कैसे करें स्ट्रिंग क्यों नहीं है? एक स्थिरता खाली है? आंशिक डाउनलोड (HTTP) का उपयोग कर फ़ाइल डाउनलोड करें

सूची (टी) और संग्रह (टी के) के बीच अंतर क्या है?

मैंने उन्हें बहुत सारे तरीकों में देखा है, और मैं चिंतित हूँ कि मैं डिजाइन में एक रास्ता नीचे जाने के बारे में हूँ, अगर मैं इसे बेहतर समझ नहीं पा रहा हूं। इसके अलावा, मैं .NET का प्रयोग कर रहा हूं।

वेब के समाधान से एकत्रित समाधान "सूची (टी) और संग्रह (टी के) के बीच अंतर क्या है?"

Collection<T> IList<T> चारों ओर एक अनुकूलन योग्य आवरण है जबकि IList<T> सील नहीं किया गया है, यह किसी भी अनुकूलन बिंदु प्रदान नहीं करता है Collection<T> के तरीकों को मानक IList<T> विधियों के लिए डिफ़ॉल्ट रूप से प्रत्यायित किया जाता है, लेकिन आप जो चाहते हैं उसे आसानी से ओवरराइड किया जा सकता है। यह Collection<T> अंदर वायरअप इवेंट्स भी संभव है Collection<T> मुझे विश्वास नहीं है कि एक आईएलआईडी के साथ किया जा सकता है

संक्षेप में, तथ्य के बाद इसका विस्तार करना बहुत आसान है, जिसका संभावित रूप से बहुत कम रिफैक्टरिंग का मतलब हो सकता है

List<T> अनुप्रयोग कोड के भीतर आंतरिक उपयोग के लिए अभिप्रेत है। आपको उन सार्वजनिक एपीआई लिखने से बचना चाहिए, जो कि List<T> स्वीकार या वापस लौटाते हैं (इसके बजाय एक सुपर क्लास या संग्रह संग्रह का उपयोग करने पर विचार करें)।

Collection<T> कस्टम संग्रह के लिए एक बेस क्लास का कार्य करता है (हालांकि इसे सीधे उपयोग किया जा सकता है)।

आपके कोड में Collection<T> का उपयोग करने पर विचार करें, जब तक कि List<T> की विशिष्ट विशेषताओं की आवश्यकता न हो।

उपरोक्त सिर्फ सिफारिशें हैं

[से अनुकूलित: फ्रेमवर्क डिजाइन दिशानिर्देश, द्वितीय संस्करण]

सी # में, वस्तुओं के एक बैग का प्रतिनिधित्व करने के लिए तीन अवधारणाएं हैं सुविधाओं को बढ़ाने के क्रम में, वे हैं:

  • एनफ़ोएबल – अनोर्ड, अनमोडिएबल
  • संग्रह – आइटम जोड़ सकते / निकालें
  • सूची – आइटम को ऑर्डर करने की अनुमति देता है (इंडेक्स द्वारा एक्सेस और निकालने)

गणना में कोई आदेश नहीं है आप सेट से आइटम जोड़ नहीं सकते हैं या निकाल नहीं सकते आप सेट में आइटम की संख्या भी नहीं प्राप्त कर सकते हैं यह सख्ती से आपको सेट में प्रत्येक आइटम का उपयोग करने देता है, दूसरे के बाद एक

संग्रह एक परिवर्तनीय सेट है आप सेट से वस्तुओं को जोड़ सकते हैं और हटा सकते हैं, आप सेट में आइटम की संख्या भी प्राप्त कर सकते हैं। लेकिन अभी भी कोई आदेश नहीं है, और क्योंकि कोई आदेश नहीं है: इंडेक्स द्वारा एक आइटम तक पहुंचने का कोई रास्ता नहीं है, न ही सॉर्ट करने का कोई तरीका नहीं है।

सूची ऑब्जेक्ट का एक ऑर्डर दिया जाता है आप सूची को सॉर्ट कर सकते हैं, इंडेक्स द्वारा आइटम्स एक्सेस कर सकते हैं, इंडेक्स द्वारा आइटम निकाल सकते हैं।

वास्तव में, जब इनके लिए इंटरफेस देख रहे हैं, वे एक दूसरे पर निर्माण करते हैं:

  • interface IEnumerable<T>

    • GetEnumeration<T>
  • interface ICollection<T> : IEnumerable<T>

    • Add
    • Remove
    • Clear
    • Count
  • interface IList<T> = ICollection<T>

    • Insert
    • IndexOf
    • RemoveAt

जब चर, या विधि पैरामीटर घोषित करते हैं, तो आपको इसका उपयोग करना चाहिए

  • IEnumerable
  • ICollection
  • IList

अवधारणा के आधार पर आपको ऑब्जेक्ट के सेट के साथ क्या करना चाहिए।

अगर आपको सूची में प्रत्येक ऑब्जेक्ट में कुछ करने में सक्षम होने की आवश्यकता है, तो आपको केवल IEnumerable आवश्यकता है:

 void SaveEveryUser(IEnumerable<User> users) { for User u in users ... } 

आपको परवाह नहीं है कि उपयोगकर्ता को List<T> , Collection<T> , Array<T> या कुछ और में रखा जाता है। आपको केवल IEnumerable<T> इंटरफ़ेस की आवश्यकता है

यदि आपको किसी सेट में आइटम जोड़ने, निकालने या गिनने में सक्षम होने की आवश्यकता है, तो एक संग्रह का उपयोग करें:

 ICollection<User> users = new Collection<User>(); users.Add(new User()); 

यदि आप किसी प्रकार के क्रम की देखभाल करते हैं, और सही होने की आवश्यकता है, तो एक सूची का उपयोग करें:

 IList<User> users = FetchUsers(db); 

चार्ट रूप में:

 | Feature | IEnumerable<T> | ICollection<T> | IList<T> | |------------------------|----------------|----------------|----------| | Enumerating items | X | X | X | | | | | | | Adding items | | X | X | | Removing items | | X | X | | Count of items | | X | X | | | | | | | Accessing by index | | | X | | Removing by indexx | | | X | | Getting index of item | | | X | 

List<T> और Collection<T> में System.Collections.GenericSystem.Collections.Generic दो इंटरफेस लागू करने वाले दो वर्ग हैं; लेकिन वे केवल कक्षाएं नहीं हैं:

  • ConcurrentBag<T> ऑब्जेक्ट्स का एक ऑर्डर किया गया बैग है ( IEnumerable<T> )
  • LinkedList<T> एक थैला है जहां आपको इंडेक्स द्वारा मदों का उपयोग करने की इजाजत नहीं है; लेकिन आप संग्रह से वस्तुओं को मनमाने ढंग से जोड़ सकते हैं और हटा सकते हैं
  • SynchronizedCollection<T> कलेक्शन SynchronizedCollection<T> एक आदेश संग्रह में, जहां आप सूचकांक द्वारा आइटम जोड़ सकते हैं / निकालें

तो आप आसानी से बदल सकते हैं:

 IEnumerable<User> users = new SynchronizedCollection<User>(); SaveEveryUser(users); 

tl; डॉ

  • अनग्रेजेबल – एक्सेस आइटम, अनारडेड, अनमोडिएबल
  • संग्रह – संशोधित किया जा सकता है (जोड़ें, हटाएं, गिनती)
  • सूची – सूचकांक द्वारा उपयोग कर सकते हैं

आपको आवश्यक अवधारणा को चुनें, फिर मेल खाने वाला क्लास का उपयोग करें।

List<T> एक बहुत ही आम तौर पर देखा जाने वाला कंटेनर है, क्योंकि यह बहुत बहुमुखी है ( Sort , Find , इत्यादि जैसे बहुत सी आसान विधियों के साथ) – लेकिन अगर आप किसी भी व्यवहार को ओवरराइड करना चाहते हैं तो कोई एक्सटेंशन अंक नहीं हैं (डालें , उदाहरण के लिए)।

Collection<T> किसी भी IList<T> ( List<T> लिए डिफ़ॉल्ट) के आसपास एक आवरण है – इसमें एक्सटेंशन पॉइंट्स ( virtual विधियां) हैं, लेकिन खोज के जैसे कई समर्थन विधियां नहीं हैं निंदा की वजह से, यह List<T> की तुलना में थोड़ा धीमा है, लेकिन बहुत ज्यादा नहीं

LINQ के साथ, List<T> में अतिरिक्त विधियां List<T> कम महत्वपूर्ण बनती हैं, क्योंकि LINQ-to-Objects उन्हें वैसे भी उपलब्ध कराने के लिए … उदाहरण के लिए First(pred) , OrderBy(...) , आदि।

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

सूची तेज है

उदाहरण के लिए करें

 private void button1_Click(object sender, EventArgs e) { Collection<long> c = new Collection<long>(); Stopwatch s = new Stopwatch(); s.Start(); for (long i = 0; i <= 10000000; i++) { c.Add(i); } s.Stop(); MessageBox.Show("collect " + s.ElapsedMilliseconds.ToString()); List<long> l = new List<long>(); Stopwatch s2 = new Stopwatch(); s2.Start(); for (long i = 0; i <= 10000000; i++) { l.Add(i); } s2.Stop(); MessageBox.Show("lis " + s2.ElapsedMilliseconds.ToString()); } 

मेरी मशीन की List<> लगभग दो बार तेज है

संपादित करें

मुझे समझ में नहीं आ रहा है कि लोग इस वजह से आगे बढ़ रहे हैं। मेरी काम मशीन और मेरी होम मशीन पर दोनों <> सूची 80% तेज है

यह उन स्नातक स्कूल प्रश्नों में से एक है। टी का एक संग्रह सार है; वहाँ एक डिफ़ॉल्ट कार्यान्वयन हो सकता है (मैं एक .net / c # guy नहीं हूँ) लेकिन एक संग्रह में बुनियादी कार्यों जैसे जोड़ने, निकालें, पुनरावृत्त, और इसी तरह होंगे।

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

Hanselman बोलती है : " Collection<T> एक सूची की तरह दिखता है, और इसमें आंतरिक List<T> भी है List<T> आंतरिक List<T> प्रत्येक एकल विधि प्रतिनिधि इसमें एक संरक्षित संपत्ति शामिल होती है जो List<T> को उजागर करती है।"

संपादित करें: Collection<T> सिस्टम में मौजूद नहीं है। Generic.Collections .NET 3.5। यदि आप .NET 2.0 से 3.5 में माइग्रेट करते हैं तो आपको कुछ कोड बदलना होगा यदि आप बहुत सारे Collection<T> ऑब्जेक्ट्स का उपयोग कर रहे हैं, जब तक कि मुझे कुछ स्पष्ट न हो …

2 संपादित करें: Collection<T> अब सिस्टम में है। Collapses.ObjectModel नामस्थान .NET 3.5 में। सहायता फ़ाइल यह कहती है:

"सिस्टम.क्लॉक्शंस। ऑब्जेक्टमॉडेल नेमस्पेस में वे वर्ग होते हैं जिन्हें पुन: प्रयोज्य लाइब्रेरी के ऑब्जेक्ट मॉडल में संग्रह के रूप में इस्तेमाल किया जा सकता है। इन वर्गों का उपयोग करें जब गुण या विधियां संग्रह को वापस करती हैं।"

इन सभी इंटरफेस IEnumerable से प्राप्त होते हैं, जिन्हें आपको सुनिश्चित करना चाहिए कि आप समझते हैं। यह इंटरफ़ेस मूल रूप से आपको क्लाउड का उपयोग एक foreach स्टेटमेंट (सी # में) में कर देता है।

  • ICollection आपके द्वारा सूचीबद्ध इंटरफेस का सबसे बुनियादी है। यह एक संख्यात्मक अंतरफलक है जो एक Count का समर्थन करता है और इसके बारे में है।
  • IList सब कुछ है जो ICollection है, लेकिन यह वस्तुओं को जोड़ने और निकालने का समर्थन करता है, इंडेक्स द्वारा आइटम्स को पुनः प्राप्त करता है। यह "ऑब्जेक्ट की सूचियों" के लिए सबसे अधिक उपयोग किया जाने वाला इंटरफ़ेस है, जो अस्पष्ट है मुझे पता है।
  • IQueryable एक अनन्य इंटरफेस है जो LINQ का समर्थन करता है। आप हमेशा एक IQueryable से IQueryable बना सकते हैं और LINQ को ऑब्जेक्ट के लिए उपयोग कर सकते हैं, लेकिन आप IQueryable को LINQ से SQL और SQL को SQL इकाइयों में स्थगित SQL कथन के लिए उपयोग किया जा सकता है।
  • IDictionary इस अर्थ में एक अलग जानवर है कि वह मूल्यों के लिए अद्वितीय कुंजियों का मानचित्रण है यह भी महत्वपूर्ण है कि आप कुंजी / मान जोड़ों की गणना कर सकते हैं, लेकिन अन्यथा यह आपके द्वारा सूचीबद्ध अन्य लोगों की तुलना में एक अलग उद्देश्य प्रदान करता है

एमएसडीएन के अनुसार, सूची (टी के) .ऐसा करें "एक ओ (एन) ऑपरेशन" (जब "क्षमता" पार हो गई है) जबकि संग्रह (टी के) .ऐसा हमेशा "एक ओ (1) ऑपरेशन" जोड़ें। यह समझा जा सकता है कि यदि सूची को एक ऐरे और संग्रह एक लिंक्ड सूची का उपयोग कर लागू किया गया है। हालांकि, अगर यह मामला होता है, तो एक संग्रह (टी के) की अपेक्षा करता है। यह "एक ओ (एन) ऑपरेशन" होना चाहिए। लेकिन – यह है – नहीं !?! संग्रह (टी के)। यह "एक ओ (1) ऑपरेशन" है, जैसे कि सूची (टी के)।

इसके ऊपर, "टुइन्स्टोएल" के "दिसम्बर 29 '08 बजे 22:31" दावे की गति परीक्षणों की सूची (टी के) दिखाती है। संग्रह (टी के) से अधिक तेज होने के लिए जोड़ें .जो मैंने पुनः प्रकाशित किया है लांग और स्ट्रिंग का हालांकि, मुझे केवल 33% तेज बनाम बना दिया गया है, इसके अनुसार, 80% दावा किया गया है, एमएसडीएन के मुताबिक, यह विपरीत और "एन" समय से होना चाहिए!

दोनों एक ही इंटरफेस को लागू करते हैं, इसलिए वे उसी तरह से व्यवहार करेंगे। शायद वे आंतरिक रूप से अलग तरीके से कार्यान्वित किए जाते हैं, लेकिन यह जांचना होगा।

केवल वास्तविक मतभेद मैं देख रहा हूँ नामस्थान और तथ्य यह है कि Collection<T> को ComVisibleAttribute(false) के साथ चिह्नित किया गया है, इसलिए COM कोड इसका उपयोग नहीं कर सकता।

अन्य बिचौलियों के अतिरिक्त, मैंने जेनेरिक सूची और संग्रह क्षमताओं का त्वरित अवलोकन संकलित किया है। संग्रह सूची का सीमित उपसेट है:

 * = मौजूद
 ओ = आंशिक रूप से उपस्थित

 संपत्ति / विधि संग्रह <T> सूची <टी>
 ---------------------------------------------- Add() * * AddRange() * AsReadOnly() * BinarySearch() * Capacity * Clear() * * Contains() * * ConvertAll() * CopyTo() o * Count * * Equals() * * Exists() * Find() * FindAll() * FindIndex() * FindLast() * FindLastIndex() * ForEach() * GetEnumerator() * * GetHashCode() * * GetRange() * GetType() * * IndexOf() o * Insert() * * InsertRange() * Item() * * LastIndexOf() * New() o * ReferenceEquals() * * Remove() * * RemoveAll() * RemoveAt() * * RemoveRange() * Reverse() * Sort() * ToArray() * ToString() * * TrimExcess() * TrueForAll() *