Splicing enumerables together Basically, what I mean by splice is to take an array of Enumerables, take the 1st element from the first one, then the 1st element from the second one, and so forth, until we come back to the 1st enumerable, and we then take the next element from it and each of the others.

Sort of like this:
[A A] [B B] [C C] [D D] [E E] [F F]
Splicing these together would produce [A B C D E F A B C D E F]

namespace xofz
{
    using System.Collections.Generic;

    public interface MaterializedEnumerable&lt;out T&gt; : IEnumerable&lt;T&gt;
    {
        long Count { get; }
    }
}


A MaterializedEnumerable is basically an enumerable which has been written to memory, so it can be iterated as many times as you want.  It also gets a Count property.

Here is the actual splice code.  Don't worry about what an OrderedMaterializedEnumerable is, just think of it for now as a wrapper for List&lt;T&gt;

namespace xofz.Transformation
{
    using System.Collections.Generic;
    using System.Linq;
    using xofz.Materialization;

    public class EnumerableSplicer
    {
        public MaterializedEnumerable&lt;T&gt; Splice&lt;T&gt;(IEnumerable&lt;T&gt;[] sources)
        {
            var lists = new List&lt;T&gt;[sources.Length];

            // first, enumerate all the items into separate lists
            for (var i = 0; i &lt; sources.Length; ++i)
            {
                lists[i] = new List&lt;T&gt;(new LinkedList&lt;T&gt;(sources[i]));
            }

            // then, splice the lists together
            var list = new List&lt;T&gt;(lists.Sum(l =&gt; l.Count));
            var smallestCount = lists.Select(l =&gt; l.Count).Min();

            for (var i = 0; i &lt; smallestCount; ++i)
            {
                list.AddRange(lists.Select(l =&gt; l[i]));
            }

            var remainingLists = new LinkedList&lt;List&lt;T&gt;&gt;();
            foreach (var l in lists)
            {
                l.RemoveRange(0, smallestCount);
                if (l.Count &gt; 0)
                {
                    remainingLists.AddLast(l);
                }
            }

            if (remainingLists.Count == 0)
            {
                return new OrderedMaterializedEnumerable&lt;T&gt;(list);
            }

            IEnumerable&lt;IEnumerable&lt;T&gt;&gt; remainingEnumerables = remainingLists;
            list.AddRange(this.Splice(remainingEnumerables.ToArray()));

            return new OrderedMaterializedEnumerable&lt;T&gt;(list);
        }
    }
}


This method is slightly recursive, to handle enumerables of different sizes.  I hope it is easy enough to read!

More transformations I wrote lately are available at xofz.Core on Github.
My comment is that you can write your desired method with far more generality, no recursion, and far less realization into lists. For example:

using System;
using System.Linq;
using System.Collections.Generic;   

public class Program
{
    public static IEnumerable&lt;R&gt; Zipper&lt;A, R&gt;(IEnumerable&lt;IEnumerable&lt;A&gt;&gt; sequences, Func&lt;IEnumerable&lt;A&gt;, R&gt; f)
    {
        var enumtors = sequences.Select(seq =&gt; seq.GetEnumerator()).ToList();
        while(true)
        {
            // Not quite kosher, as we are using Select to cause a side effect!
            var hasValues = enumtors.Select(e =&gt; e.MoveNext());
            if (hasValues.Any(v =&gt; !v)) 
                break;
            yield return f(enumtors.Select(e =&gt; e.Current));
        }
        foreach(var enumtor in enumtors)
          enumtor.Dispose();
    }

    public static void Main()
    {
        foreach(var s in Zipper(
            new[] { 
              new[] {1, 2}, 
              new[] {3, 4}, 
              new[] {5, 6, 7} }, 
            x =&gt; string.Join("-", x))) 
          Console.WriteLine(s);
    }
}


Produces output

1-3-5
2-4-6


Note that my version works on infinite lists provided that there are finitely many of them.  Note also that my method is "lazy"; it only makes computations when the caller "pulls" something.