एक नए IEnumerable <T> में दो IEnumerable <T> कैसे संक्षिप्त करें?

Question

मेरे पास IEnumerable<T>(उसी के साथ T) के दो उदाहरण हैं । मैं एक नया उदाहरण चाहता हूं, IEnumerable<T>जिसमें दोनों की सहमति हो।

क्या ऐसा करने के लिए .Net में एक अंतर्निहित विधि है या क्या मुझे इसे स्वयं लिखना है?

Comments

आप code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b को बुकमार्क करना चाह सकते हैं ।

— सी-पाउंड गुरु

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

— नवफाल

Answer 1

हाँ, वस्तुओं के लिए LINQ इस के साथ समर्थन करता है Enumerable.Concat:

var together = first.Concat(second);

नायब: आपको अशक्त होना चाहिए firstया secondनहीं ArgumentNullException। इससे बचने के लिए और नल का इलाज करने के लिए जैसा कि आप एक खाली सेट चाहते हैं, इस तरह अशक्त तालमेल ऑपरेटर का उपयोग करें:

var together = (first ?? Enumerable.Empty<string>()).Concat(second ?? Enumerable.Empty<string>()); //amending `<string>` to the appropriate type

Comments

मैं हमेशा विस्तार के तरीकों, टीएक्स को देखना भूल जाता हूं।

— सैमुअल रॉसिल

@SamuelRossille यह भी मत भूलो कि जिन क्रियाओं का आप प्रदर्शन करना चाहते हैं, उनके नाम संभवतः पास हैं यदि आप वास्तव में नहीं कहे जाते हैं कि आप क्या हैं। हमेशा IntelliSense ब्राउज़ करें, आप बहुत कुछ सीखते हैं।

— एडम हल्ड्सवर्थ

क्या दूसरा = पहला करना गलत है। कॉनकट (दूसरा)? क्या हमारे पास कोई समसामयिक मुद्दे होंगे?

— user2934433

@ user2934433: नहीं, यह बिल्कुल ठीक है।

— जॉन स्कीट

बस एक त्वरित नोट। using System.Linq IDE इंटैलिसेंस में वांछित एक्सटेंशन विधि को देखने के लिए कोड फ़ाइल के शीर्ष पर नाम स्थान आयात करना आवश्यक है ।

— RBT

Answer 2

Concatविधि एक वस्तु जो औजार वापस आ जाएगी IEnumerable<T>एक वस्तु लौटाएँ (यह बिल्ली कहते हैं) जिसका प्रगणक का उपयोग करने का प्रयास करेंगे दो पारित कर दिया-इन गणनीय आइटम अनुक्रम में (उन्हें ए और बी कहते हैं)। यदि पारित-किए गए एन्यूमरैबल्स अनुक्रमों का प्रतिनिधित्व करते हैं, जो बिल्ली के जीवनकाल के दौरान नहीं बदलेगा, और जिसे बिना साइड-इफेक्ट के पढ़ा जा सकता है, तो बिल्ली का सीधे उपयोग किया जा सकता है। अन्यथा, इसके परिणामस्वरूप कॉल ToList()करने Catऔर उपयोग करने के लिए एक अच्छा विचार हो सकता है List<T>(जो ए और बी की सामग्री के स्नैपशॉट का प्रतिनिधित्व करेगा)।

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

Answer 3

आप अपने समाधान के लिए नीचे दिए गए कोड का उपयोग कर सकते हैं: -

public void Linq94() 
{ 
    int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 }; 
    int[] numbersB = { 1, 3, 5, 7, 8 }; 

    var allNumbers = numbersA.Concat(numbersB); 

    Console.WriteLine("All numbers from both arrays:"); 
    foreach (var n in allNumbers) 
    { 
        Console.WriteLine(n); 
    } 
}

Answer 4

// The answer that I was looking for when searching
public void Answer()
{
    IEnumerable<YourClass> first = this.GetFirstIEnumerableList();
    // Assign to empty list so we can use later
    IEnumerable<YourClass> second = new List<YourClass>();

    if (IwantToUseSecondList)
    {
        second = this.GetSecondIEnumerableList();  
    }
    IEnumerable<SchemapassgruppData> concatedList = first.Concat(second);
}