c# - सूची <टी> या IList <टी>





generics (16)


public void Foo(IList<Bar> list)
{
     // Do Something with the list here.
}

इस मामले में आप किसी भी वर्ग में प्रवेश कर सकते हैं जो IList <Bar> इंटरफ़ेस लागू करता है। यदि आपने सूची <बार> का उपयोग किया है, तो केवल एक सूची <बार> उदाहरण पास किया जा सकता है।

सूची <बार> रास्ता की तुलना में आईएलआईस्ट <बार> रास्ता अधिक ढीला है।

क्या कोई मुझे बता सकता है कि मैं सूची में आईएलआईस्ट पर सूची का उपयोग क्यों करना चाहूंगा?

संबंधित प्रश्न: List<T> का पर्दाफाश करना क्यों बुरा माना जाता है




यह आश्चर्यजनक है कि इनमें से कोई भी सूची बनाम आईएलआईटी प्रश्न (या उत्तर) हस्ताक्षर अंतर का उल्लेख नहीं करता है। (यही कारण है कि मैंने इस सवाल की खोज SO पर की है!)

तो यहां सूची द्वारा निहित विधियां हैं जो कम से कम .NET 4.5 (लगभग 2015) के रूप में, IList में नहीं मिलती हैं।

  • AddRange
  • AsReadOnly
  • द्विआधारी खोज
  • क्षमता
  • सभी को रूपांतरित करें
  • मौजूद
  • खोज
  • सब ढूँढ़ो
  • FindIndex
  • FindLast
  • FindLastIndex
  • प्रत्येक के लिए
  • GetRange
  • InsertRange
  • LastIndexOf
  • सभी हटाएं
  • RemoveRange
  • रिवर्स
  • तरह
  • toArray
  • TrimExcess
  • TrueForAll



कंक्रीट कार्यान्वयन पर इंटरफ़ेस का उपयोग करने के संबंध में उपरोक्त अधिकांश उत्तरों में सभी अवधारणाओं को मूल रूप से बताया गया है।

IList<T> defines those methods (not including extension methods)

IList<T> एमएसडीएन लिंक

  1. जोड़ना
  2. स्पष्ट
  3. शामिल
  4. को कॉपी
  5. GetEnumerator
  6. के सूचकांक
  7. सम्मिलित करें
  8. हटाना
  9. RemoveAt

List<T> उन नौ तरीकों को लागू करती है (विस्तार विधियों सहित), इसके शीर्ष पर इसके बारे में 41 सार्वजनिक विधियां हैं, जो आपके आवेदन में उपयोग करने के लिए आपके विचार में वजन रखते हैं।

List<T> एमएसडीएन लिंक




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

यदि आप इसे आंतरिक रूप से उपयोग कर रहे हैं, तो आप परवाह नहीं कर सकते हैं, और List<T> का उपयोग ठीक हो सकता है।




IList <T> एक इंटरफ़ेस है ताकि आप किसी अन्य वर्ग का उत्तराधिकारी हो सकें और अभी भी सूची <टी> को प्रबंधित करने के दौरान IList <T> को लागू कर सकें।

उदाहरण के लिए यदि कक्षा ए है और आपकी कक्षा बी को विरासत में मिला है तो आप सूची <टी> का उपयोग नहीं कर सकते हैं

class A : B, IList<T> { ... }



क्या होगा यदि .NET 5.0 System.Collections.Generic.List<T> को प्रतिस्थापित करता है। .NET हमेशा नाम List<T> का मालिक है लेकिन वे गारंटी देते हैं कि IList<T> एक अनुबंध है। तो आईएमएचओ हम (कम से कम मैं) किसी के नाम का उपयोग नहीं करना चाहते हैं (हालांकि यह इस मामले में .NET है) और बाद में परेशानी में पड़ता है।

IList<T> का उपयोग करने के मामले में, कॉलर हमेशा काम करने के लिए अनुमानित चीजें हैं, और कार्यान्वयनकर्ता अंतर्निहित संग्रह को IList किसी भी वैकल्पिक ठोस कार्यान्वयन में बदलने के लिए स्वतंत्र है




इंटरफ़ेस यह सुनिश्चित करता है कि आप कम से कम उन विधियों को प्राप्त करें जिन्हें आप उम्मीद कर रहे हैं ; इंटरफ़ेस की परिभाषा के बारे में जागरूक होना यानी। इंटरफेस विरासत में प्राप्त किसी भी वर्ग द्वारा लागू किए जाने वाले सभी अमूर्त तरीकों। इसलिए यदि कोई व्यक्ति कुछ विधियों के साथ इंटरफ़ेस से विरासत में प्राप्त किए गए कई विधियों के साथ अपनी खुद की एक विशाल श्रेणी बनाता है, और उन लोगों के लिए इसका कोई उपयोग नहीं है, तो उप-वर्ग के संदर्भ का उपयोग करना बेहतर है (इस मामले में इंटरफ़ेस) और कंक्रीट क्लास ऑब्जेक्ट को असाइन करें।

अतिरिक्त लाभ यह है कि आपका कोड कंक्रीट क्लास में किसी भी बदलाव से सुरक्षित है क्योंकि आप कंक्रीट क्लास के कुछ तरीकों की सदस्यता ले रहे हैं और वे तब तक वहां जा रहे हैं जब तक कंक्रीट क्लास इंटरफ़ेस से प्राप्त न हो का उपयोग करते हुए। इसलिए आपके लिए सुरक्षा और कोडर की आजादी जो ठोस कंक्रीट कक्षा में अपनी कार्यक्षमता को बदलने या जोड़ने के लिए ठोस कार्यान्वयन लिख रही है।




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




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

वास्तुकला अंतरिक्ष यात्री । संभावना है कि आप कभी भी अपना खुद का आईएलआईस्ट लिखेंगे जो पहले से ही .NET ढांचे में से कुछ को जोड़ता है, यह इतनी दूरदराज है कि सैद्धांतिक जेली टट्टियां "सर्वोत्तम प्रथाओं" के लिए आरक्षित हैं।

जाहिर है अगर आपसे पूछा जा रहा है कि आप एक साक्षात्कार में किस चीज का उपयोग करते हैं, तो आप कहते हैं कि इस्लामी, मुस्कान, और दोनों इतनी चतुर होने के लिए खुद को प्रसन्न करते हैं। या एक सार्वजनिक सामना एपीआई, IList के लिए। उम्मीद है कि आप मेरा मुद्दा प्राप्त करेंगे।




IList <> अन्य पोस्टर की सलाह के मुताबिक लगभग हमेशा बेहतर होता है, हालांकि ध्यान दें कि डब्लूसीएफ डाटाकंट्रैक्टसेरियलाइज़र के साथ धारावाहिक / deserialization के एक से अधिक चक्र के माध्यम से एक आईएलआईटी <> चलाते समय .NET 3.5 SP 1 में एक बग है

इस बग को ठीक करने के लिए अब एक एसपी है: केबी 971030




आम तौर पर, आपके सार्वजनिक सामना करने वाले एपीआई (जब उपयुक्त हो, और सूची अर्थशास्त्र की आवश्यकता होती है) में आईएलआईस्ट का उपयोग करना एक अच्छा तरीका है, और उसके बाद एपीआई को लागू करने के लिए आंतरिक रूप से सूचीबद्ध करें। यह आपको अपनी कक्षा का उपयोग करने वाले कोड को तोड़ने के बिना IList के एक अलग कार्यान्वयन में बदलने की अनुमति देता है।

क्लास नाम सूची अगले .NET ढांचे में बदला जा सकता है लेकिन अंतरफलक कभी भी परिवर्तित नहीं होगा क्योंकि इंटरफ़ेस अनुबंध है।

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




मैं कंक्रीट कार्यान्वयन पर इंटरफ़ेस का उपयोग क्यों करना चाहिए, यह साबित करने के बजाय, आप इंटरफ़ेस के बजाय ठोस कार्यान्वयन का उपयोग क्यों करेंगे, यह पुष्टि करने के बजाय, मैं थोड़ा सा प्रश्न बदलूंगा। यदि आप इसे उचित नहीं ठहरा सकते हैं, तो इंटरफ़ेस का उपयोग करें।




टीडीडी और ओओपी का एक सिद्धांत आमतौर पर एक इंटरफेस के लिए प्रोग्रामिंग है जो कार्यान्वयन नहीं करता है।

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

ऐसा करने की लागत कम है, क्यों बाद में सिरदर्द को बचाओ? इंटरफ़ेस सिद्धांत यह सब कुछ है।




इंटरफेस एक वादा (या एक अनुबंध) है।

जैसा कि यह हमेशा वादे के साथ होता है - बेहतर छोटा होता है




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

इसके अलावा कुछ करने की शक्ति भी है जैसे सूची <T> के कार्यान्वयन के लिए तालिका <टी> के कार्यान्वयन को संशोधित करने के लिए। <dd>। किसी भी अन्य IList विधि डेवलपर को बहुत लचीलापन और शक्ति देता है, अन्यथा पूर्वनिर्धारित सूची <टी> द्वारा




append करें एक सूची में एक तत्व जोड़ता है, और दूसरी सूची के साथ पहली सूची को जोड़ता है (या एक अन्य पुनरावर्तनीय, जरूरी नहीं कि एक सूची।)

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

डाइव से पायथन में





c# list generics