IEnumerable बनाम सूची - उपयोग करने के लिए क्या? वो कैसे काम करते है?

Question

मुझे कुछ संदेह है कि Enumerators कैसे काम करते हैं, और LINQ। इन दो सरल चयनों पर विचार करें:

List<Animal> sel = (from animal in Animals 
                    join race in Species
                    on animal.SpeciesKey equals race.SpeciesKey
                    select animal).Distinct().ToList();

या

IEnumerable<Animal> sel = (from animal in Animals 
                           join race in Species
                           on animal.SpeciesKey equals race.SpeciesKey
                           select animal).Distinct();

मैंने अपनी मूल वस्तुओं के नाम बदल दिए ताकि यह अधिक सामान्य उदाहरण जैसा लगे। क्वेरी ही महत्वपूर्ण नहीं है। मैं यह पूछना चाहता हूं:

foreach (Animal animal in sel) { /*do stuff*/ }

1. मैंने देखा कि यदि मैं उपयोग करता हूं IEnumerable, जब मैं "sel" का डिबग और निरीक्षण करता हूं, जो उस मामले में IEnumerable है, तो इसमें कुछ दिलचस्प सदस्य हैं: "आंतरिक", "बाहरी", "innerKeySelector" और "" externalKeySelector ", ये अंतिम 2 दिखाई देते हैं प्रतिनिधि बनना है। "आंतरिक" सदस्य में "पशु" उदाहरण नहीं है, बल्कि "प्रजाति" उदाहरण हैं, जो मेरे लिए बहुत अजीब था। "बाहरी" सदस्य में "पशु" उदाहरण हैं। मुझे लगता है कि दो प्रतिनिधियों ने यह निर्धारित किया है कि इसमें क्या जाता है और इससे बाहर क्या जाता है?

2. मैंने देखा कि यदि मैं "डिस्टिक्ट" का उपयोग करता हूं, तो "इनर" में 6 आइटम हैं (यह गलत है क्योंकि केवल 2 डिस्टिंक्ट हैं), लेकिन "बाहरी" में सही मान शामिल हैं। फिर, शायद प्रत्यायोजित विधियाँ इसे निर्धारित करती हैं लेकिन यह IEnumerable के बारे में जितना मुझे पता है उससे थोड़ा अधिक है।

3. सबसे महत्वपूर्ण बात, दो विकल्पों में से कौन सा सबसे अच्छा प्रदर्शन-वार है?

बुराई सूची के माध्यम से रूपांतरण .ToList()?

या शायद सीधे एन्यूमरेटर का उपयोग कर रहा है?

यदि आप कर सकते हैं, तो कृपया थोड़ा स्पष्ट करें या कुछ लिंक फेंक दें जो IEnumerable के इस उपयोग की व्याख्या करते हैं।

Answer 1

IEnumerableव्यवहार का वर्णन करता है, जबकि सूची उस व्यवहार का कार्यान्वयन है। जब आप उपयोग करते हैं IEnumerable, तो आप कंपाइलर को बाद में काम करने का मौका देते हैं, संभवतः रास्ते में अनुकूलन करते हैं। यदि आप ToList () का उपयोग करते हैं, तो आप कंपाइलर को परिणामों को तुरंत संशोधित करने के लिए मजबूर करते हैं।

जब भी मैं LINQ अभिव्यक्तियों का "स्टैकिंग" कर रहा हूं, मैं उपयोग करता हूं IEnumerable, क्योंकि केवल उस व्यवहार को निर्दिष्ट करके मैं LINQ को मूल्यांकन को स्थगित करने और संभवतः प्रोग्राम को ऑप्टिमाइज़ करने का मौका देता हूं। याद रखें कि जब तक आप इसे एन्यूमरेट नहीं करते, तब तक LINQ SQL को डेटाबेस को क्वेरी करने के लिए कैसे उत्पन्न नहीं करता है? इस पर विचार करो:

public IEnumerable<Animals> AllSpotted()
{
    return from a in Zoo.Animals
           where a.coat.HasSpots == true
           select a;
}

public IEnumerable<Animals> Feline(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Felidae"
           select a;
}

public IEnumerable<Animals> Canine(IEnumerable<Animals> sample)
{
    return from a in sample
           where a.race.Family == "Canidae"
           select a;
}

अब आपके पास एक विधि है जो एक प्रारंभिक नमूना ("AllSpotted") का चयन करती है, साथ ही कुछ फ़िल्टर भी। तो अब आप यह कर सकते हैं:

var Leopards = Feline(AllSpotted());
var Hyenas = Canine(AllSpotted());

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

एक कार्यक्रम में, अपनी क्वेरी को किसी सूची में परिवर्तित करने के लिए अंत तक बेहतर हो सकता है, इसलिए यदि मैं तेंदुए और हाइना के माध्यम से एक से अधिक बार गणना करने जा रहा हूं, तो मैं यह करूंगा:

List<Animals> Leopards = Feline(AllSpotted()).ToList();
List<Animals> Hyenas = Canine(AllSpotted()).ToList();

Comments

मुझे लगता है कि वे दोनों पक्षों में शामिल होने का उल्लेख करते हैं। यदि आप "जानवरों से प्रजातियों का चयन करें" करते हैं ... "तो जुड़ने का आंतरिक भाग पशु है, और बाहरी भाग प्रजाति है।

— क्रिस वेनहम

जब मैंने इसके बारे में उत्तर पढ़े हैं: IEnumerable <T> बनाम IQueryable <T> मैंने एनालॉग विवरण देखा, ताकि IEnumerable स्वचालित रूप से संग्रह को क्वेरी करने के लिए LINQ का उपयोग ऑब्जेक्ट के लिए रनटाइम के लिए करता है। तो मैं इन 3 प्रकारों के बीच भ्रमित हूं। stackoverflow.com/questions/2876616/…

— ब्रोंक

@Bronek आपके द्वारा जोड़ा गया उत्तर सत्य है। IEnumerable<T>पहले भाग के बाद LINQ-To-Objects होगा जिसका अर्थ है कि सभी स्पॉट किए गए Feline को चलाने के लिए वापस करना होगा। दूसरी ओर, IQuertable<T>वसीयत को केवल स्पॉट किए गए फ़ील्ड्स को नीचे खींचकर क्वेरी को परिष्कृत करने की अनुमति देगा।

— नैट

यह जवाब बहुत ही भ्रामक है! @ नैट की टिप्पणी बताती है कि क्यों। यदि आप IEnumerable <T> का उपयोग कर रहे हैं, तो फ़िल्टर क्लाइंट की ओर से होने वाला है, चाहे जो भी हो।

— हंस

हाँ आवंटित () दो बार चलाया जाएगा। इस उत्तर के साथ बड़ी समस्या निम्न कथन है: "उपरोक्त में, लीपर्ड और हाइना एक एकल एसक्यूएल प्रश्नों में परिवर्तित हो जाते हैं, और डेटाबेस केवल उन पंक्तियों को वापस करता है जो प्रासंगिक हैं।" यह गलत है, क्योंकि जहां क्लॉज़ को IEnumerable <> पर कॉल किया जा रहा है और यह केवल उन वस्तुओं के माध्यम से लूप करना जानता है जो पहले से डेटाबेस से आ रहे हैं। यदि आपने आवंटित किया () और एफलाइन () और कैनाइन () के मापदंडों को IQueryable में वापस किया, तो फ़िल्टर SQL में होगा और यह उत्तर समझ में आएगा।

— हंस

Answer 2

द्वारा लिखित एक बहुत अच्छा लेख है: क्लाउडियो बर्नसकोनी की TechBlog यहाँ: जब IEnumerable, ICollection, IList और सूची का उपयोग करने के लिए

यहाँ कुछ मूल बातें परिदृश्यों और कार्यों के बारे में बताती हैं:

Comments

यह ध्यान दिया जाना चाहिए कि यह लेख केवल आपके कोड के सार्वजनिक सामना करने वाले हिस्सों के लिए है, आंतरिक कामकाज के लिए नहीं। Listके एक कार्यान्वयन है IListऔर इस तरह के लोगों के ऊपर अतिरिक्त कार्यक्षमता है के रूप में IList(जैसे Sort, Find, InsertRange)। यदि आप अपने आप को उपयोग करने के लिए मजबूर करते IListहैं List, तो आप इन तरीकों को ढीला करते हैं जिनकी आपको आवश्यकता हो सकती है

— जोनाथन ट्विट

मत भूलोIReadOnlyCollection<T>

— Dandré

[]यहाँ एक सादा सरणी को भी शामिल करना मददगार हो सकता है ।

— jbyrd

जबकि यह पर फेंक दिया जा सकता है, इस ग्राफिक और लेख को साझा करने के लिए धन्यवाद

— डैनियल

Answer 3

लागू करने वाला एक वर्ग IEnumerableआपको foreachसिंटैक्स का उपयोग करने की अनुमति देता है ।

मूल रूप से यह संग्रह में अगले आइटम प्राप्त करने के लिए एक विधि है। स्मृति में होने के लिए उसे पूरे संग्रह की आवश्यकता नहीं है और यह नहीं जानता कि इसमें कितने आइटम हैं, foreachबस अगले आइटम को तब तक प्राप्त करता रहता है जब तक यह बाहर नहीं निकल जाता है।

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

अब Listलागू होता है IEnumerable, लेकिन स्मृति में पूरे संग्रह का प्रतिनिधित्व करता है। यदि आपके पास एक है IEnumerableऔर आप कहते हैं कि .ToList()आप स्मृति में गणना की सामग्री के साथ एक नई सूची बनाते हैं।

आपकी linq अभिव्यक्ति एक एन्यूमरेशन लौटाती है, और डिफ़ॉल्ट रूप से एक्सप्रेशन को निष्पादित करता है जब आप इसका उपयोग करके पुनरावृति करते हैं foreach। एक IEnumerablelinq स्टेटमेंट निष्पादित करता है जब आप इसे पुनरावृत्त करते हैं foreach, लेकिन आप इसका उपयोग करने के लिए इसे तुरंत पुनरावृत्त करने के लिए बाध्य कर सकते हैं .ToList()।

यहाँ मेरा मतलब है:

var things = 
    from item in BigDatabaseCall()
    where ....
    select item;

// this will iterate through the entire linq statement:
int count = things.Count();

// this will stop after iterating the first one, but will execute the linq again
bool hasAnyRecs = things.Any();

// this will execute the linq statement *again*
foreach( var thing in things ) ...

// this will copy the results to a list in memory
var list = things.ToList()

// this won't iterate through again, the list knows how many items are in it
int count2 = list.Count();

// this won't execute the linq statement - we have it copied to the list
foreach( var thing in list ) ...

Comments

लेकिन क्या होता है अगर आप एक IEnumerable पर एक सूची के लिए इसे बदलने के बिना एक पहले पर अमल करते हैं ? क्या यह पूरे संग्रह को स्मृति में लाता है? या, क्या यह तत्व को एक-एक करके तुरंत कर देता है, क्योंकि यह फॉर्च लूप से अधिक है? धन्यवाद

— पैप

@ उत्तरार्द्ध: यह फिर से निष्पादित करता है, कुछ भी स्वचालित रूप से स्मृति में कैश नहीं किया जाता है।

— कीथ

ऐसा लगता है कि मुख्य अंतर 1 है) पूरी बात स्मृति में है या नहीं। 2) IEnumerable मुझे का उपयोग foreachकरते हैं जबकि सूची कहना सूचकांक द्वारा जाना होगा। अब, अगर मुझे पता करना चाहते हैं गिनती / लंबाई की thingपहले से, IEnumerable में मदद नहीं करेगा, है ना?

— 23:50 पर Jeb50

@ Jeb50 बिल्कुल नहीं - दोनों Listऔर Arrayलागू IEnumerable। आप IEnumerableएक न्यूनतम सामान्य भाजक के रूप में सोच सकते हैं जो मेमोरी संग्रह और बड़े दोनों के लिए काम करता है जो एक समय में एक आइटम प्राप्त करते हैं। जब आप कॉल करते हैं तो IEnumerable.Count()आप एक तेज .Lengthसंपत्ति को कॉल कर सकते हैं या पूरे संग्रह से गुजर सकते हैं - मुद्दा यह है कि आपके साथ IEnumerableनहीं पता है। यह एक समस्या हो सकती है, लेकिन अगर आप बस इसके लिए जा रहे foreachहैं तो आप परवाह नहीं करते हैं - आपका कोड एक Arrayया DataReaderउसी के साथ काम करेगा ।

— कीथ

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

— कीथ

Answer 4

किसी ने भी एक महत्वपूर्ण अंतर का उल्लेख नहीं किया, विडंबना यह है कि एक प्रश्न पर इसका उत्तर दिया गया।

IEnumerable केवल-पढ़ने के लिए है और सूची नहीं है।

सूची और IEnumerable के बीच व्यावहारिक अंतर देखें

Comments

अनुवर्ती के रूप में, यह है कि इंटरफ़ेस पहलू के कारण या सूची पहलू के कारण? यानी IList भी आसानी से पढ़ा जाता है?

— जेसन मास्टर्स

IList केवल पढ़ने के लिए नहीं है - docs.microsoft.com/en-us/dotnet/api/… IEnumerable केवल पढ़ने के लिए है क्योंकि इसमें किसी भी चीज़ को जोड़ने या हटाने का कोई तरीका नहीं है, क्योंकि यह निर्माण किया जाता है, यह आधार स्थानों में से एक है IList का विस्तार (लिंक देखें)

— CAD

Answer 5

एहसास करने के लिए सबसे महत्वपूर्ण बात यह है कि, Linq का उपयोग करते हुए, क्वेरी का तुरंत मूल्यांकन नहीं किया जाता है। यह केवल IEnumerable<T>एक में जिसके परिणामस्वरूप के माध्यम से पुनरावृत्ति के भाग के रूप में चलाया जाता हैforeach - यही सब अजीब प्रतिनिधियों कर रहे हैं।

इसलिए, पहला उदाहरण क्वेरी को कॉल करके ToListऔर सूची में परिणाम डालकर तुरंत मूल्यांकन करता है ।
दूसरा उदाहरण रिटर्न देता IEnumerable<T>है जिसमें बाद में क्वेरी को चलाने के लिए आवश्यक सभी जानकारी होती है।

प्रदर्शन के संदर्भ में, इसका उत्तर यह निर्भर करता है । यदि आपको परिणामों का मूल्यांकन एक बार में करने की आवश्यकता है (कहते हैं, आप उन संरचनाओं को परिवर्तित कर रहे हैं जिन्हें आप बाद में क्वेरी कर रहे हैं, या यदि आप IEnumerable<T>लंबे समय तक चलना नहीं चाहते हैं ) तो एक सूची का उपयोग करें। एल्स यूज़ ए IEnumerable<T>। दूसरे उदाहरण में ऑन-डिमांड मूल्यांकन का उपयोग करने के लिए डिफ़ॉल्ट होना चाहिए, क्योंकि आम तौर पर कम मेमोरी का उपयोग होता है, जब तक कि किसी सूची में परिणामों को संग्रहीत करने का कोई विशिष्ट कारण नहीं होता है।

Comments

नमस्ते और उत्तर देने के लिए धन्यवाद :: -)। इससे मेरे लगभग सभी संदेह दूर हो गए। किसी भी विचार क्यों Enumerable "आंतरिक" और "बाहरी" में "विभाजित" है? यह तब होता है जब मैं माउस के माध्यम से डिबग / ब्रेक मोड में तत्व का निरीक्षण करता हूं। क्या यह शायद विजुअल स्टूडियो का योगदान है? मौके पर गणना करना और एनम के इनपुट और आउटपुट का संकेत देना?

— एक्सोपन

यह Joinकाम कर रहा है - भीतरी और बाहरी जुड़ने के दो पहलू हैं। आमतौर पर, इस बारे में चिंता न करें कि वास्तव में क्या है IEnumerables, क्योंकि यह आपके वास्तविक कोड से पूरी तरह से अलग होगा। केवल वास्तविक आउटपुट के बारे में चिंता करें जब आप उस पर पुनरावृत्ति करते हैं :)

— thecoop

Answer 6

IEnumerable का लाभ स्थगित निष्पादन (आमतौर पर डेटाबेस के साथ) है। जब तक आप वास्तव में डेटा के माध्यम से लूप नहीं करेंगे तब तक क्वेरी निष्पादित नहीं होगी। जब तक इसकी ज़रूरत (उर्फ आलसी लोडिंग) नहीं है, तब तक यह एक प्रतीक्षा है।

यदि आप ToList को कॉल करते हैं, तो क्वेरी निष्पादित की जाएगी, या "भौतिक रूप में" जैसा कि मैं कहना चाहता हूं।

दोनों के पक्ष और विपक्ष हैं। यदि आप ToList को कॉल करते हैं, तो आप क्वेरी के निष्पादित होने पर कुछ रहस्य निकाल सकते हैं। यदि आप IEnumerable से चिपके रहते हैं, तो आपको यह लाभ मिलता है कि कार्यक्रम तब तक कोई काम नहीं करता है जब तक कि वास्तव में इसकी आवश्यकता न हो।

Answer 7

मैं एक गलत अवधारणा को साझा करूंगा जिसे मैं एक दिन में गिर गया:

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));


// updating existing list
names[0] = "ford";

// Guess what should be printed before continuing
print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

अपेक्षित परिणाम

// I was expecting    
print( startingWith_M.ToList() ); // mercedes, mazda
print( startingWith_F.ToList() ); // fiat, ferrari

वास्तविक परिणाम

// what printed actualy   
print( startingWith_M.ToList() ); // mazda
print( startingWith_F.ToList() ); // ford, fiat, ferrari

व्याख्या

अन्य उत्तरों के अनुसार, ToListउदाहरण के लिए आह्वान या इसी तरह के आह्वान विधियों तक परिणाम का मूल्यांकन स्थगित कर दिया गया थाToArray ।

इसलिए मैं इस मामले में कोड को फिर से लिख सकता हूं:

var names = new List<string> {"mercedes", "mazda", "bmw", "fiat", "ferrari"};

// updating existing list
names[0] = "ford";

// before calling ToList directly
var startingWith_M = names.Where(x => x.StartsWith("m"));

var startingWith_F = names.Where(x => x.StartsWith("f"));

print( startingWith_M.ToList() );
print( startingWith_F.ToList() );

घेर कर खेलते हैं

https://repl.it/E8Ki/0

Comments

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

— ब्रोनक

वास्तव में, मैंने सभी उत्तर पढ़े, और तुम्हारा वही था जिसे मैंने अप-वोट किया था, क्योंकि यह स्पष्ट रूप से LINQ / SQL के बारे में बात किए बिना दोनों के बीच अंतर बताता है। यह आवश्यक है कि आप LINQ / SQL से पहले यह सब जान लें। की तारीफ करें।

— बेमेर्जुइ

यह समझाने के लिए एक महत्वपूर्ण अंतर है लेकिन आपका "अपेक्षित परिणाम" वास्तव में अपेक्षित नहीं है। आप इसे ऐसा कह रहे हैं जैसे यह डिज़ाइन के बजाय किसी प्रकार का गोच है।

— नेमे

@ नीम, हाँ यह मेरी अपेक्षा थी, इससे पहले कि मैं समझता हूँ कि कैसे IEnumerableकाम करता है, लेकिन अब और अधिक नहीं है क्योंकि मैं जानता हूँ कि कैसे;)

— amd

Answer 8

यदि आप सभी उन्हें करना चाहते हैं, तो उन्हें उपयोग करें IEnumerable।

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

Comments

मुझे यकीन नहीं है कि यह कहना सुरक्षित है कि सूची बनाने का मतलब है कम प्रदर्शन।

— स्टीवन सुदित

@ स्टीवन: वास्तव में के रूप में thecoop और क्रिस ने कहा, कभी-कभी एक सूची का उपयोग करना आवश्यक हो सकता है। मेरे मामले में, मैंने यह निष्कर्ष निकाला है कि यह नहीं है। @ डैरन: "मेमोरी में प्रत्येक तत्व के लिए एक नई सूची बनाएंगे" से आपका क्या मतलब है? शायद आपका मतलब "सूची प्रविष्टि" था? :: -)।

— 17

@Axonn हाँ, मैं सूची प्रविष्टि का उल्लेख करता हूँ। तय की।

— डैरन थॉमस

@Steven यदि आप में तत्वों पर पुनरावृति करने की योजना बना रहे हैं IEnumerable, तो पहले एक सूची बनाएं (और उस पर पुनरावृत्ति करें) का अर्थ है कि आप तत्वों पर दो बार पुनरावृति करेंगे । इसलिए जब तक आप सूची में अधिक कुशल संचालन करना चाहते हैं, इसका वास्तव में मतलब कम प्रदर्शन है।

— डैरन थॉमस

@ जेरेवेट: यह एक अच्छा विचार नहीं है कि किसी अनुक्रम को संशोधित किया जाए। बुरी बातें होंगी। अंश लीक हो जाएंगे। दानव हमारे आयाम में टूटेंगे और कहर बरपाएंगे। तो हाँ, .ToList()यहाँ मदद करता है;)

— डैरन थॉमस

Answer 9

ऊपर पोस्ट किए गए सभी उत्तरों के अलावा, यहां मेरे दो सेंट हैं। सूची के अलावा और भी कई प्रकार हैं जो IEnumerable को कार्यान्वित करते हैं जैसे कि ICollection, ArrayList आदि। इसलिए यदि हमारे पास IEnumerable किसी भी विधि के पैरामीटर के रूप में है, तो हम किसी भी संग्रह प्रकार को फ़ंक्शन में पास कर सकते हैं। यानी हम अमूर्त पर काम करने के लिए विधि कर सकते हैं कोई विशेष कार्यान्वयन नहीं।

Answer 10

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

अंतर यह है कि "सूची" ऑब्जेक्ट "अभी और यहीं" संग्रहीत किए जाते हैं, जबकि "IEnumerable" ऑब्जेक्ट "एक समय में सिर्फ एक" काम करते हैं। इसलिए अगर मैं ईबे पर सभी वस्तुओं के माध्यम से जा रहा हूं, तो एक समय में कुछ ऐसा होगा जो एक छोटा कंप्यूटर भी संभाल सकता है, लेकिन ".TLList ()" निश्चित रूप से मुझे मेमोरी से बाहर चलाएगा, चाहे मेरा कंप्यूटर कितना भी बड़ा हो। कोई भी कंप्यूटर अपने आप में इतनी बड़ी मात्रा में डेटा को समाहित और संभाल नहीं सकता है।

[संपादित करें] - कहने की ज़रूरत नहीं है - यह "या तो यह या वह" नहीं है। अक्सर यह एक ही कक्षा में एक सूची और एक IEnumerable दोनों का उपयोग करने के लिए अच्छा समझ में आता है। दुनिया का कोई भी कंप्यूटर सभी अभाज्य संख्याओं को सूचीबद्ध नहीं कर सकता है, क्योंकि परिभाषा के अनुसार इसके लिए अनंत मात्रा में मेमोरी की आवश्यकता होती है। लेकिन आप आसानी से सोच सकते हैं कि class PrimeContainerइसमें एक शामिल है IEnumerable<long> primes, जो स्पष्ट कारणों के लिए भी एक है SortedList<long> _primes। अब तक की गणना की सभी primes। अगले प्राइम की जाँच केवल मौजूदा प्राइम (वर्गमूल तक) के विरुद्ध की जाएगी। इस तरह से आप दोनों को प्राप्त करते हैं - एक समय में एक (IEnumerable) और "primes अब तक" की एक अच्छी सूची, जो पूरी (अनंत) सूची का एक बहुत अच्छा अनुमान है।