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<out T> : IEnumerable<T>    {        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<T>namespace xofz.Transformation{    using System.Collections.Generic;    using System.Linq;    using xofz.Materialization;    public class EnumerableSplicer    {        public MaterializedEnumerable<T> Splice<T>(IEnumerable<T>[] sources)        {            var lists = new List<T>[sources.Length];            // first, enumerate all the items into separate lists            for (var i = 0; i < sources.Length; ++i)            {                lists[i] = new List<T>(new LinkedList<T>(sources[i]));            }            // then, splice the lists together            var list = new List<T>(lists.Sum(l => l.Count));            var smallestCount = lists.Select(l => l.Count).Min();            for (var i = 0; i < smallestCount; ++i)            {                list.AddRange(lists.Select(l => l[i]));            }            var remainingLists = new LinkedList<List<T>>();            foreach (var l in lists)            {                l.RemoveRange(0, smallestCount);                if (l.Count > 0)                {                    remainingLists.AddLast(l);                }            }            if (remainingLists.Count == 0)            {                return new OrderedMaterializedEnumerable<T>(list);            }            IEnumerable<IEnumerable<T>> remainingEnumerables = remainingLists;            list.AddRange(this.Splice(remainingEnumerables.ToArray()));            return new OrderedMaterializedEnumerable<T>(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.
Splicing enumerables together
c#;iterator