附加/连接两个 IEnumerable 序列

Question

我有两组数据行。它们都是 IEnumerable。我想将这两个列表附加/连接到一个列表中。我确信这是可行的。我不想做for循环，注意到两个List上有一个Union方法和一个Join方法。有什么想法吗？

Answer 1

假设您的对象属于同一类型，您可以使用 Union 或 Concat。请注意，与 SQL UNION 关键字一样，Union 操作将确保消除重复项，而 Concat （如 UNION ALL< /code>) 只会将第二个列表添加到第一个列表的末尾。

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

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

或者

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

如果它们属于不同类型，那么您必须将它们选择为共同的类型。例如：

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) 表示以某种方式转换 TOne 实例的操作（并且 >TTwo，分别）到 T 的实例中。

Answer 2

我刚刚遇到了类似的情况，需要连接多个序列。

自然地在 Google/StackOverflow 上搜索现有解决方案，但是没有找到任何未评估可枚举的内容，例如转换为数组然后使用 Array.Copy() 等，所以我编写了一个扩展和静态名为 ConcatMultiple 的实用方法。

希望这可以帮助任何需要这样做的人。

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

加入方法类似于 SQL 连接，其中列表根据条件交叉引用，它不是字符串连接或添加到列表。 Union 方法确实可以满足您的要求，就像Concat 方法，但都是 LAZY 评估，并且要求参数非空。它们返回 ConcatIterator 或 UnionIterator，并且 如果重复调用，这可能引起问题。急切的评估会导致不同的行为，如果这是您想要的，那么可以使用如下的扩展方法。

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

Answer 4

延迟调用第二个及后续枚举

我通常使用 Linq IEnumerable.Concat() 但今天我需要 100% 确定第二个枚举未被枚举直到第一个处理完毕为止。 （例如，我不想同时运行两个数据库查询）。所以下面的函数巧妙地延迟了枚举。

    IEnumerable<T> DelayedConcat<T>(params Func<IEnumerable<T>>[] enumerableList)
    {
        foreach(var enumerable in enumerableList)
        {
            foreach (var item in enumerable())
            {
                yield return item;
            }
        }
    }

用法：

    return DelayedConcat(
                () => GetEnumerable1(),
                () => GetEnumerable2(),
 // and so on.. () => GetEnumerable3(),
                );

在此示例中，GetEnumerable2 函数调用将被延迟，直到 GetEnumerable1 枚举完毕为止。