将 N 个 IEnumerable<T> 压缩在一起？同时迭代它们？

Question

我有：-

IEnumerable<IEnumerable<T>> items;

我想创建：-

IEnumerable<IEnumerable<T>> results;

其中“results”中的第一项是“items”的每个 IEnumerables 的第一项的 IEnumerable，“results”中的第二项是每个“items”的第二项的 IEnumerable，等等.

IEnumerables 的长度不一定相同。如果项目中的某些 IEnumerable 在特定索引处没有元素，那么我希望结果中匹配的 IEnumerable 中的项目更少。

例如：-

items = { "1", "2", "3", "4" } , { "a", "b", "c" };
results = { "1", "a" } , { "2", "b" }, { "3", "c" }, { "4" };

编辑：另一个示例（在 cmets 中请求）：-

items = { "1", "2", "3", "4" } , { "a", "b", "c" }, { "p", "q", "r", "s", "t" };
results = { "1", "a", "p" } , { "2", "b", "q" }, { "3", "c", "r" }, { "4", "s" }, { "t" };

我事先不知道有多少个序列，也不知道每个序列有多少个元素。我可能有 1,000 个序列，每个序列有 1,000,000 个元素，我可能只需要前 10 个，所以如果可以的话，我想使用源序列的（惰性）枚举。如果可以的话，我尤其不想创建新的数据结构。

是否有内置方法（类似于 IEnumerable.Zip）可以做到这一点？

还有其他方法吗？

Answer 1

现在经过轻微测试并可以正常处理。

public static class Extensions
{
  public static IEnumerable<IEnumerable<T>> JaggedPivot<T>(
    this IEnumerable<IEnumerable<T>> source)
  {
    List<IEnumerator<T>> originalEnumerators = source
      .Select(x => x.GetEnumerator())
      .ToList();

    try
    {
      List<IEnumerator<T>> enumerators = originalEnumerators
        .Where(x => x.MoveNext()).ToList();

      while (enumerators.Any())
      {
        List<T> result = enumerators.Select(x => x.Current).ToList();
        yield return result;
        enumerators = enumerators.Where(x => x.MoveNext()).ToList();
      }
    }
    finally
    {
      originalEnumerators.ForEach(x => x.Dispose());
    }
  } 
}

public class TestExtensions
{
  public void Test1()
  {
    IEnumerable<IEnumerable<int>> myInts = new List<IEnumerable<int>>()
    {
      Enumerable.Range(1, 20).ToList(),
      Enumerable.Range(21, 5).ToList(),
      Enumerable.Range(26, 15).ToList()
    };

    foreach(IEnumerable<int> x in myInts.JaggedPivot().Take(10))
    {
      foreach(int i in x)
      {
        Console.Write("{0} ", i);
      }
      Console.WriteLine();
    }
  }
}

Answer 2

合理如果你能保证结果将如何被使用的话，这很容易做到。但是，如果结果可能以任意顺序使用，您可能需要缓冲所有内容。考虑一下：

var results = MethodToBeImplemented(sequences);
var iterator = results.GetEnumerator();
iterator.MoveNext();
var first = iterator.Current;
iterator.MoveNext();
var second = iterator.Current;
foreach (var x in second)
{
    // Do something
}
foreach (var x in first)
{
    // Do something
}

为了获得“第二个”中的项目，您必须遍历所有子序列，过去第一个项目。如果您希望它有效地迭代 first 中的项目，您要么需要记住这些项目或准备重新评估子序列。 p>

同样，您要么需要将子序列缓冲为 IEnumerable<T> 值，要么每次都重新读取整个批次。

基本上这是一整罐蠕虫，很难优雅地以​​一种适用于所有情况的方式优雅地完成:(如果您有一个特定的情况并有适当的限制，我们可能会能够提供更多帮助。

Answer 3

这是一个较短的，但无疑效率较低：

Enumerable.Range(0,items.Select(x => x.Count()).Max())
    .Select(x => items.SelectMany(y => y.Skip(x).Take(1)));

Answer 4

这个怎么样？

        List<string[]> items = new List<string[]>()
        {
            new string[] { "a", "b", "c" },
            new string[] { "1", "2", "3" },
            new string[] { "x", "y" },
            new string[] { "y", "z", "w" }
        };

        var x = from i in Enumerable.Range(0, items.Max(a => a.Length))
                select from z in items
                       where z.Length > i
                       select z[i];

Answer 5

你可以像这样组合现有的运算符，

IEnumerable<IEnumerable<int>> myInts = new List<IEnumerable<int>>()
    {
        Enumerable.Range(1, 20).ToList(),
        Enumerable.Range(21, 5).ToList(),
        Enumerable.Range(26, 15).ToList()
    };

myInts.SelectMany(item => item.Select((number, index) => Tuple.Create(index, number)))
      .GroupBy(item => item.Item1)
      .Select(group => group.Select(tuple => tuple.Item2));

Answer 6

基于David B's answer，这段代码应该性能更好：

public static IEnumerable<IEnumerable<T>> JaggedPivot<T>(
    this IEnumerable<IEnumerable<T>> source)
{
    var originalEnumerators = source.Select(x => x.GetEnumerator()).ToList();
    try
    {
        var enumerators =
            new List<IEnumerator<T>>(originalEnumerators.Where(x => x.MoveNext()));

        while (enumerators.Any())
        {
            yield return enumerators.Select(x => x.Current).ToList();
            enumerators.RemoveAll(x => !x.MoveNext());
        }
    }
    finally
    {
        originalEnumerators.ForEach(x => x.Dispose());
    }
}

不同之处在于 enumerators 变量不会一直重新创建。