上文讲的Count和LongCount返回的是数值类型，本文我们讲的Concat返回的是一个序列。
 

Concat是什么？

Concat只有一种签名形式，这让它使用起来很简单：

public static IEnumerable<TSource> Concat<TSource>( 

    this IEnumerable<TSource> first, 

    IEnumerable<TSource> second)

Concat的返回值依次包含了两个序列中的元素，也就是说把两个序列串联起来了。

我有时会觉得.NET没有提供Prepend/Append这样的方法是个遗憾，这两个方法应该可以和Concat做类似的事情，只不过它们把一个序列和一个单个的元素串联起来。如果要做一个填充着国家名和一个“None”值的下拉列表的话，这两个方法是很有用的。当然，向Concat中传入一个单元素的数组也可以达到同样的目的，但是我个人认为用特定的方法名做特定的事会让代码的可读性更高。MoreLINQ中的Concat方法可以做这件事，不过Edulinq的目的只是要实现LINQ to Objects中已有的方法。

和往常一样，我们列出Concat的行为：

l 参数校验需要立即执行：两个参数都不允许为null

l 返回值是延迟执行的：当Concat被调用时，两个参数不会立即被迭代

l 输入序列只有在需要的时候才会被迭代：如果你停止迭代输出序列时第一个输入序列还没有被耗尽的话，那么第二个序列根本就不会被迭代

这几点描述基本就涵盖了Concat的所有行为。

我们需要测试什么呢？

Concat的串联行为很容易被测试，只需要一个用例就够了。我们或许也可以测试输入空序列会如何，但是那种测试基本没有不通过的可能。

参数校验的测试方式和往常一样：调用方法时传入非法的参数，然后不去迭代方法的返回值。

最后，还有一个单元测试用来测试两个输入序列被迭代的时机。这个测试中用到了我们在测试Where时用过的ThrowingEnumerable：

[Test] 

public void FirstSequenceIsntAccessedBeforeFirstUse() 

{ 

    IEnumerable<int> first = new ThrowingEnumerable(); 

    IEnumerable<int> second = new int[] { 5 }; 

    // No exception yet... 

    var query = first.Concat(second); 

    // Still no exception... 

    using (var iterator = query.GetEnumerator()) 

    { 

        // Now it will go bang 

        Assert.Throws<InvalidOperationException>(() => iterator.MoveNext()); 

    } 

} 

[Test] 

public void SecondSequenceIsntAccessedBeforeFirstUse() 

{ 

    IEnumerable<int> first = new int[] { 5 }; 

    IEnumerable<int> second = new ThrowingEnumerable(); 

    // No exception yet... 

    var query = first.Concat(second); 

    // Still no exception... 

    using (var iterator = query.GetEnumerator()) 

    { 

        // First element is fine... 

        Assert.IsTrue(iterator.MoveNext()); 

        Assert.AreEqual(5, iterator.Current); 

        // Now it will go bang, as we move into the second sequence 

        Assert.Throws<InvalidOperationException>(() => iterator.MoveNext()); 

    } 

}

我们写测试来检查迭代器是否被Dispose掉了。但是我们可以预测到输入序列的迭代器应该会被合理的Dispose掉。实际上，第一个序列的迭代器会在第二个序列开始被迭代之前就被Dispose掉。

开始动手实现吧！

Concat的实现虽然比较简单，但是我写完之后还是觉得F#更值得拥有...实现分为参数校验和迭代器代码块两部分，每一部分都不复杂：

public static IEnumerable<TSource> Concat<TSource>( 

    this IEnumerable<TSource> first, 

    IEnumerable<TSource> second) 

{ 

    if (first == null) 

    { 

        throw new ArgumentNullException("first"); 

    } 

    if (second == null) 

    { 

        throw new ArgumentNullException("second"); 

    } 

    return ConcatImpl(first, second); 

} 

private static IEnumerable<TSource> ConcatImpl<TSource>( 

    IEnumerable<TSource> first, 

    IEnumerable<TSource> second) 

{ 

    foreach (TSource item in first) 

    { 

        yield return item; 

    } 

    foreach (TSource item in second) 

    { 

        yield return item; 

    } 

}

如果不能利用迭代器代码块的话，这个实现会变得很麻烦。虽然不会特别难，但是我们需要记住当前正在迭代的是哪个序列。

如果是在用F#的话，我们可以使用yield!表达式来把它实现的更简单，yield!表达式作用于一整个序列而不是单个的元素。必需得承认在这种场景下使用yield!并不会带来什么性能上的提升（如果是在递归的场景下就很可能会有性能提升），但是能够用一个语句来yield返回整个序列确实是一种更优雅的风格。（Spec#中也有一个类似的结构叫做嵌套迭代器，用yield foreach来表示。）我对F#和Spec#了解的都不够深入，所以就不做更深入的比较了。不过我们在以后实现Edulinq的过程中还会遇到好几次“yield返回一个序列中的每个元素”的模式。请记住，我们不能把yield返回的代码抽取到一个单独的方法中去，因为“yield”表达式需要C#编译器的特殊处理。

结论

虽然我用的实现方式还是蛮简单的，但是我还是吐槽一下：） 如果C#里面也有嵌套迭代器那多好啊，虽然说没有它也没有令我太苦恼。

Concat是一个很有用的操作符，不过它也不过是SelectMany的一个特例罢了。Concat只能把两个序列连接成一个序列，而SelectMany则可以把很多个序列连接成一个序列，而且SelectMany在有时还更有普遍性。下次我们会实现SelectMany，而且会展示一些基于SelectMany来实现其他操作符的例子。（等实现Aggregate的时候，我们会再次见到操作符只返回一个值的例子。）

附录：避免不必要的保持引用

有一条留言建议说要在遍历完第一个序列后把它设为null。这样，在遍历完第一个序列后，它就可以被垃圾回收了。如果采取这个建议，那么实现起来会是这样的：

private static IEnumerable<TSource> ConcatImpl<TSource>( 

    IEnumerable<TSource> first, 

    IEnumerable<TSource> second) 

{ 

    foreach (TSource item in first) 

    { 

        yield return item; 

    } 

    // Avoid hanging onto a reference we don't really need 

    first = null; 

    foreach (TSource item in second) 

    { 

        yield return item; 

    } 

}

在普通情况下，把一个不再使用的局部变量设为null这种做法是没用的。因为当CLR在执行优化过的代码，并且没有挂上调试器时，垃圾收集器只关心在方法内部可能还会被访问的变量。

但是在我们这个特例中，这么做还是有用的。因为第一个参数并不是一个简单的局部变量，在C#编译器生成的隐藏类型中，它是一个实例字段，而CLR无法判断实例字段是否会被再次使用。

或许我们可以在调用GetEnumerator之前清空掉我们对“first”这个参数的唯一引用。我们可以写一个这样的方法：

public static T ReturnAndSetToNull<T>(ref T value) where T : class 

{ 

    T tmp = value; 

    value = null; 

    return tmp; 

}

然后这样调用它：

foreach (TSource item in ReturnAndSetToNull(ref first))

我认为这样做绝对是有点过了，因为迭代器有可能还会持有对集合的引用。不过在遍历之后把“first”这个参数设为null在我看来是说得通的。

需要提醒你一下，我觉得.NET的LINQ to Objects的实现里面是不会这样做的。（以后我可能会用一个有finalizer的集合类来测试一下。）