Ajout / concaténation de deux séquences IEnumerable

Question

J'ai deux ensembles de datarows. Ils sont chacun IEnumerable. Je veux annexer / concaténer ces deux listes en une seule. Je suis sûr que c'est faisable. Je ne veux pas faire de boucle for et j'ai remarqué qu'il y a une méthode Union et une méthode Join sur les deux listes. Des idées?

Answer 1

En supposant que vos objets sont du même type, vous pouvez utiliser Union ou Concat. Notez que, comme le SQL UNION mot, de la Union opération permettra de s'assurer que les doublons sont éliminés, alors que Concat (comme UNION ALL) il suffit d'ajouter la deuxième liste à la fin de la première.

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

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

ou

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

Si elles sont de différents types, alors vous devrez Select dans quelque chose de commun. Par exemple:

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

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

Où ConvertToT(TOne f) et ConvertToT(TTwo s) représentent une opération qui, en quelque sorte convertit une instance d' TOne (et TTwo, respectivement) dans une instance d' T.

Answer 2

Je viens de rencontrer une situation similaire où je dois concaténer plusieurs séquences.

Naturellement, nous avons recherché des solutions existantes sur Google / StackOverflow, mais n’avons rien trouvé qui n’ait pas évalué l’énumérable. Par exemple, convertir en tableau puis utiliser Array.Copy() etc., j’ai donc écrit une méthode d’extension et statique appelée ConcatMultiple .

J'espère que cela aide tous ceux qui doivent faire de même.

 /// <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;
    }
}