How does Concat() actually join the collections at lower level?

Question

What is Linq actually doing?

Answer 1

(I'm assuming this is for LINQ to Objects. Anything else will be implemented differently :)

It's just returning everything from the first, and then everything from the second. All data is streamed. Something like this:

public static IEnumerable<T> Concat(this IEnumerable<T> source1,
    IEnumerable<T> source2)
{
    if (source1 == null)
    {
        throw new ArgumentNullException("source1");
    }
    if (source2 == null)
    {
        throw new ArgumentNullException("source1");
    }
    return ConcatImpl(source1, source2);
}


private static IEnumerable<T> ConcatImpl(this IEnumerable<T> source1,
    IEnumerable<T> source2)
{
    foreach (T item in source1)
    {
        yield return item;
    }
    foreach (T item in source2)
    {
        yield return item;
    }
}

I've split this into two methods so that the argument validation can be performed eagerly but I can still use an iterator block. (No code within an iterator block is executed until the first call to MoveNext() on the result.)

Answer 2

It enumerates each collection in turn, and yields each element. Something like that :

public static IEnumerable<T> Concat<T>(this IEnumerable<T> source, IEnumerable<T> other)
{
    foreach(var item in source) yield return item;
    foreach(var item in other) yield return item;
}

(if you look at the actual implementation using Reflector, you will see that the iterator is actually implemented in a separate method)

Answer 3

It depends on the LINQ provider you are using. LinqToSql or L2E might use a database UNION, whereas LINQ to Objects might just enumerate both collections for your in turn.