दो आईन्यूमेरेबल अनुक्रमों को जोड़ना/संक्षिप्त करना

Question

मेरे पास डैटरोज के दो सेट हैं। वे प्रत्येक IENumerable हैं। मैं इन दो सूचियों को एक सूची में जोड़ना/जोड़ना चाहता हूं। मुझे यकीन है कि यह करने योग्य है। मैं लूप के लिए नहीं करना चाहता हूं और देखा कि एक यूनियन विधि और दो सूचियों पर एक जॉइन विधि है। कोई विचार?

Answer 1

मान लें कि आपकी ऑब्जेक्ट एक ही प्रकार के हैं, आप या तो Union या Concat का उपयोग कर सकते हैं। ध्यान दें कि, SQL UNION कीवर्ड की तरह, Union ऑपरेशन यह सुनिश्चित करेगा कि डुप्लिकेट समाप्त हो जाएंगे, जबकि Concat (जैसे UNION ALL) केवल पहले के अंत में दूसरी सूची जोड़ देगा।

IEnumerable<T> first = ...; 
IEnumerable<T> second = ...; 

IEnumerable<T> combined = first.Concat(second); 

या

IEnumerable<T> combined = first.Union(second); 

वे अलग अलग प्रकार के होते हैं, तो आप Select करने के लिए उन्हें कुछ आम में होगा। उदाहरण के लिए:

IEnumerable<TOne> first = ...; 
IEnumerable<TTwo> second = ...; 

IEnumerable<T> combined = first.Select(f => ConvertToT(f)).Concat(
          second.Select(s => ConvertToT(s))); 

कहाँ ConvertToT(TOne f) और ConvertToT(TTwo s) एक ऑपरेशन है कि किसी तरह T का एक उदाहरण में TOne (और TTwo, क्रमशः) का एक उदाहरण धर्मान्तरित प्रतिनिधित्व करते हैं।

Answer 2

मुझे बस इसी तरह की स्थिति का सामना करना पड़ा जहां मुझे कई अनुक्रमों को संयोजित करने की आवश्यकता है।

स्वाभाविक रूप से Google/StackOverflow पर मौजूदा समाधानों की खोज की गई, हालांकि कुछ भी नहीं मिला जो कि गणना करने योग्य नहीं था, उदाहरण के लिए सरणी में कनवर्ट करें, फिर Array.Copy() आदि का उपयोग करें, इसलिए मैंने ConcatMultiple नामक एक एक्सटेंशन और स्थैतिक utiltiy विधि लिखा था।

उम्मीद है कि यह किसी को भी ऐसा करने में मदद करेगा।

/// <summary> 
/// Concatenates multiple sequences 
/// </summary> 
/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam> 
/// <param name="first">The first sequence to concatenate.</param> 
/// <param name="source">The other sequences to concatenate.</param> 
/// <returns></returns> 
public static IEnumerable<TSource> ConcatMultiple<TSource>(this IEnumerable<TSource> first, params IEnumerable<TSource>[] source) 
{ 
    if (first == null) 
     throw new ArgumentNullException("first"); 

    if (source.Any(x => (x == null))) 
     throw new ArgumentNullException("source"); 

    return ConcatIterator<TSource>(source); 
} 

private static IEnumerable<TSource> ConcatIterator<TSource>(IEnumerable<TSource> first, params IEnumerable<TSource>[] source) 
{ 
    foreach (var iteratorVariable in first) 
     yield return iteratorVariable; 

    foreach (var enumerable in source) 
    { 
     foreach (var iteratorVariable in enumerable) 
      yield return iteratorVariable; 
    } 
} 

/// <summary> 
/// Concatenates multiple sequences 
/// </summary> 
/// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>   
/// <param name="source">The sequences to concatenate.</param> 
/// <returns></returns> 
public static IEnumerable<TSource> ConcatMultiple<TSource>(params IEnumerable<TSource>[] source) 
{ 
    if (source.Any(x => (x == null))) 
     throw new ArgumentNullException("source"); 

    return ConcatIterator<TSource>(source); 
} 

private static IEnumerable<TSource> ConcatIterator<TSource>(params IEnumerable<TSource>[] source) 
{ 
    foreach (var enumerable in source) 
    { 
     foreach (var iteratorVariable in enumerable) 
      yield return iteratorVariable; 
    } 
} 

Answer 3

Join विधि किसी SQL में शामिल होने, जहां सूची पार एक शर्त पर आधारित संदर्भित कर रहे हैं की तरह है, यह एक स्ट्रिंग संयोजन या किसी सूची में जोड़ा जा रहा है नहीं है। Union विधि आप जो चाहते हैं वह करता है, जैसा कि Concat विधि है, लेकिन दोनों LAZY मूल्यांकन हैं, और आवश्यकताएं पैरामीटर गैर-शून्य हैं। वे या तो एक कंसटइटरेटर या यूनियनइटरेटर, और if called repeatedly this could cause problems लौटते हैं। अलग-अलग व्यवहार में उत्सुक मूल्यांकन परिणाम, यदि आप यही चाहते हैं, तो नीचे दी गई एक विस्तार विधि का उपयोग किया जा सकता है।

public static IEnumerable<T> myEagerConcat<T>(this IEnumerable<T> first, 
                IEnumerable<T> second) 
{ 
    return (first ?? Enumerable.Empty<T>()).Concat(
      (second ?? Enumerable.Empty<T>())).ToList(); 
}