एक आईनेमरेबल संग्रह में एकल तत्व जोड़ने का सबसे अच्छा तरीका क्या है?

Question

मुझे यह हैरान है कि एक आईनेमरेबल संग्रह में एकल तत्व जोड़ने का कोई तरीका प्रतीत नहीं होता है।

मैं एक आईनेमरेबल संग्रह में एक तत्व कैसे जोड़ सकता हूं?

Answer 1

आप वास्तव में नहीं तत्वों एक IEnumerable के रूप में यह केवल पढ़ने के लिए चाहिए था जोड़ सकते हैं।

return new List<Foo>(enumerable){ new Foo() }; 

या

return enumerable.Concat(new [] { new Foo() }); 

Answer 2

आप एक सिंगलटन सरणी के साथ जोड़ सकते हैं:

IEnumerable xs; 
xs.Concat(new[]{x}); 

Answer 3

IEnumerable की बात है कि यह एक केवल पढ़ने के लिए पुल शैली संग्रह है। यदि आप चाहते हैं, तो आप कुछ इस तरह कर रही द्वारा एक ऐड अनुकरण कर सकते हैं:

public static IEnumerable<T> Add<T>(this IEnumerable<T> source, T additionalItem) 
{ 
    foreach(var item in source) 
    { 
     yield return item; 
    } 

    yield return additionalItem; 
} 

Answer 4

IEnumerable से अधिक आइटम पुनरावृत्ति करने के लिए बनाया गया है: आपका सर्वश्रेष्ठ दांव या तो कुछ की तरह है। यह हमेशा इसके समर्थन के रूप में एक संग्रह नहीं है। साथ ही, जब आप किसी संग्रह के माध्यम से लूपिंग करते हैं, तो आप संग्रह को संशोधित नहीं कर सकते हैं।

यदि आपको इसे चालू करते समय अपने संग्रह को अपडेट करने की आवश्यकता है, तो आपको अपना foreach लूप शुरू करने से पहले एक प्रतिलिपि बनाना होगा। LINQ की ToList() विधि ऐसा करने का एक अच्छा तरीका है।

Answer 5

जो उत्तर आप ढूंढ रहे हैं वह हो सकता है, लेकिन जेनेरिक संग्रह कक्षाओं का उपयोग करना हमेशा मेरे लिए इस तरह की समस्याओं को हल करने लगता है। उनमें से ज्यादातर में एक है। (टी) विधि।

Answer 6

आईनेमरेबल एक पठन केवल संग्रह है, आईसीओलेक्शन एक विस्थापन संग्रह को जोड़ने और निकालने के साथ प्रदान करता है।

लेकिन अगर आप 2 सूचियों श्रृंखलाबद्ध करके एक नया IEnumerable मूल IEnumerable और एक नए आइटम, में सभी आइटम बना सकते हैं:

var newCollection = original.Concat(new[]{element}); 

Answer 7

मैं यहाँ अन्य उत्तर में से कुछ के लिए बाहर बात करने के लिए करना चाहते हैं कि IENumerable केवल पढ़ने के संग्रह नहीं है, यह बिल्कुल एक संग्रह नहीं है। यह एक इंटरफ़ेस है जो परिभाषित करता है कि संग्रह को कैसे पुन: चालू किया जा सकता है।

यदि आप ऑब्जेक्ट्स जोड़ना चाहते हैं तो आपको ऑब्जेक्ट्स को अपनी कंक्रीट संग्रह कक्षा में जोड़ना चाहिए या कम से कम एक अलग इंटरफ़ेस का उपयोग करना चाहिए।

Answer 8

ध्यान में रखते हुए दूसरों ने जो कहा है, वास्तव में एक संख्या में "जोड़ने" में सक्षम नहीं होने के बारे में, आप अभी भी जोड़ अनुकरण कर सकते हैं। असल में, मैं तर्क दूंगा कि आप अनुक्रम को एक नए अनुक्रम में बदलकर अनुक्रम में "जोड़" सकते हैं जो वास्तव में आइटम को "शामिल" करता है (यदि आप मुझ पर विश्वास नहीं करते हैं तो बस नए अनुक्रम पर फिर से शुरू करें!) ।

//ToEnumerable might not be the best name here 
public static IEnumerable<T> ToEnumerable<T>(this T item) 
{ 
    return Enumerable.Repeat(item,1); 
} 

या

public static IEnumerable<T> ToEnumerable<T>(this T item) 
{ 
    yield return item; 
} 

तो फिर तुम एक आइटम एक गणनीय को इस तरह "जोड़ें" कर सकते हैं::

आप भी इस तरह एक गणनीय कुछ के रूप में एक आइटम व्यक्त कर सकते हैं

var items = GetSomeItems(); 

var itemsWithNewItemOnEnd = items.Concat(somenewitem.ToEnumerable()); 

var itemsWithNewItemAtStart = somenewitem.ToEnumerable().Concat(items); 

आप आइटम को इस तरह के अनुक्रम में किसी अन्य स्थान में भी डाल सकते हैं (माना जाता है कि आप जानते हैं जिस स्थिति के बाद आप इसे सम्मिलित करना चाहते हैं):

var itemsWithNewItemInserted = items.Take(5).Concat(somenewitem.ToEnumerable()).Concat(items.Skip(5)); 

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

var itemsWithNewItemInserted = items.Take(5).Concat(somenewitem.ToEnumerable()).Concat(items.Skip(5)).ToList(); 

अब itemsWithNewItemInserted एक है सूची जिसमें मूल सूची से सभी वांछित आइटम शामिल हैं, मध्य में डाली गई नई वस्तुओं के साथ।

इस तरह के अनुक्रमों के साथ चारों ओर मूर्खतापूर्ण (लेना, छोड़ना, डालना आदि) आपको समय के साथ खर्च कर सकता है क्योंकि प्रत्येक अतिरिक्त विस्तार विधि (टेक, छोड़ें, आदि) अनुक्रम को कई बार पुनरावृत्त कर सकती है, लेकिन सूची समझ वाक्यविन्यास संचालन को अभिव्यक्त करना आसान बनाता है जो परंपरागत पुनरावृत्ति का उपयोग करके काफी अधिक दृढ़ दिखता है।

इसके अलावा, यहाँ कुछ लिंक है कि IEnumerable के रूप में एक आइटम को व्यक्त करने के बारे में बात कर रहे हैं:

Passing a single item as IEnumerable<T>

Is there a neater linq way to 'Union' a single item?