在 C# 中将多个 IEnumerable<T> 提要混合为一个

Question

我经常需要在有IEnumerable<T> A、IEnumerable<T> B 的地方执行操作，并且我想创建IEnumerable<T> C，其中 C 将从 A 获取 2T，然后从 B 获取 1T，然后再次从 A 获取 2T，然后从 B 获取 1T等等 - AABAABAAB...

C# 中是否有一些语言结构，也许是一些 LINQ 表达式可以轻松完成。

现在我编写了一个小助手类，使我能够做到这一点：

var C = EnumerableMixer(new int[]{2, 1}, A, B):

    public class EnumerableMixer<T> : IEnumerable<T>
    {
        int[] Quantity;
        IEnumerable<T>[] Args;

        public EnumerableMixer(int[] quantity, params IEnumerable<T>[] args)
        {
            this.Quantity = quantity;
            this.Args = args;
            if (quantity.Length != args.Length)
                throw new NotImplementedException("Quantity must have same length as number of args!");
        }

        IEnumerable<T> Mix
        {
            get
            {
                var available = new List<int>(Quantity.Length);
                var enumerators = new List<IEnumerator<T>>(Quantity.Length);
                for (int i = 0; i < Quantity.Length; ++i)
                {
                    available.Add(i);
                    enumerators.Add(Args[i].GetEnumerator());
                }
                while (available.Count > 0)
                {
                    for (int i = 0; i < available.Count; ++i)
                    {
                        var id = available[i];
                        for (int j = 0; j < Quantity[id]; ++j)
                        {
                            if (enumerators[id].MoveNext())
                                yield return enumerators[id].Current;
                            else
                            {
                                available.RemoveAt(i);
                                i--;
                                break;
                            }
                        }
                    }
                }
            }
        }

        #region IEnumerable<T> Members

        public IEnumerator<T> GetEnumerator()
        {
            return Mix.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        #endregion
    }

Answer 1

版本 1

这是基于 adhie 的解决方案。它会考虑该比率并在退出该方法之前完全完成这两个序列。 flag 用于跟踪最后一个循环是否产生了任何东西。当flag 为假时，两个序列都被耗尽。

public IEnumerable<T> Mix<T>(IEnumerable<T> sequenceA, IEnumerable<T> sequenceB, int ratioA, int ratioB)
{
    var etorA = sequenceA.GetEnumerator();
    var etorB = sequenceB.GetEnumerator();
    bool flag = true;

    while(flag)
    {
        flag = false;

        for(int i = 0; i < ratioA && (flag |= etorA.MoveNext()); i++)
            yield return etorA.Current;

        for(int i = 0; i < ratioB && (flag |= etorB.MoveNext()); i++)
            yield return etorB.Current;
    }
}

版本 2

与版本 1 几乎相同，但采用可变数量的序列。

public IEnumerable<T> Mix<T>(params KeyValuePair<IEnumerable<T>, uint>[] quantifiedSequences)
{
    var sequences = quantifiedSequences.Select(x => new { Etor = x.Key.GetEnumerator(), Quantity = x.Value });
    bool flag = true;

    while(flag)
    {
        foreach (var sequence in sequences)
            for(int i = 0; i < sequence.Quantity && (flag |= sequence.Etor.MoveNext()); i++)
                yield return sequence.Etor.Current;
    }
}

Answer 2

稍长一点的解决方案是：

    public IEnumerable<TValue> Mix<TValue>(IEnumerable<TValue> a, IEnumerable<TValue> b)
    {
        var aEnumerator = a.GetEnumerator();
        var bEnumerator = b.GetEnumerator();

        while (true)
        {
            if (!aEnumerator.MoveNext())
            {
                yield break;
            }

            yield return aEnumerator.Current;

            if (!aEnumerator.MoveNext())
            {
                yield break;
            }

            yield return aEnumerator.Current;

            if (!bEnumerator.MoveNext())
            {
                yield break;
            }

            yield return bEnumerator.Current;
        }
    }

此解决方案不会创建不必要的对象。如果你对 yield 关键字不熟悉：http://msdn.microsoft.com/en-us/library/9k7k7cf0.aspx

Answer 3

这是我的 Linq 解决方案：

为每个元素分配一个索引，然后以正确的顺序获取元素。

// for example. You can use with any type
IEnumerable<Int32> listA = new List<Int32>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
IEnumerable<Int32> listB = new List<Int32>() { 101, 102, 103, 104, 105, 106, 107, 108, 109, 110};

// you want 2 of list A and 1 of list B. You can change the values
Int16[] quantity = new Int16[] { 2, 1 };

IEnumerable<Int32> listC = listA.Select((e, i) => new  { element = e, index = (i / (quantity[0]) * (quantity[0] + quantity[1]) + (i%quantity[0]))})
                                .Concat(listB.Select((e, i) => new  { element = e, index = (i / (quantity[1]) * (quantity[0] + quantity[1]) + (i%quantity[1]) + quantity[0])}))
                                .OrderBy(e => e.index)
                                .Select(e => e.element);

结果是IEnumerable<Int32>：1、2、101、3、4、102、5、6、103、7、8、104 ...

困难的是确定索引。它适用于您想要的（{2,1}、{3,2}、...）

对于第一个列表：

index = i/(quantity[0]) * (quantity[0]+quantity[1]) + (i%quantity[0]) + 0

对于第二个列表：

index = i/(quantity[1]) * (quantity[0]+quantity[1]) + (i%quantity[1]) + quantity[0]