Question

我喜欢选择所有数据作为不可预测数量的四元包（每个包含四个项目的包），如下所示：

foreach(var quaternary in myEnauerable.ToQuaternaryPackages())
{
    //Whatever (Like: l=page.Add(new List()))
    foreach(var item in quaternary)
    {
        //Whatever (Like: l.Add(item))
    }
}

Answer 1

我认为您正在寻找类似MoreLINQ Batch方法的内容：

foreach (var batch in myEnumerable.Batch(4))
{
    foreach (var item in batch)
    {
        // ...
    }
}

请注意，如果总数不能被4整除，则最终批次将少于4个项目。（例如，如果最初有14个项目，您将获得3个批次，然后是2个批次。）

您可以将{More}以one big Nuget package或单个包（例如the Batch package）获取。

Answer 2

首先，制作一个简单的Batch方法（将它放在一个静态类中）：

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> source, int batchSize)
{
    List<T> temp = new List<T>();
    foreach (T item in source)
    {
        temp.Add(item);
        if (temp.Count == batchSize)
        {
            yield return temp.Select(n => n);
            temp.Clear();
        }
    }
    if (temp.Any())
    {
        yield return temp.Select(n => n);
    }
}

然后就这样使用它：

foreach(var quaternary in myEnauerable.Batch(4))
{
    //Whatever (Like: l=page.Add(new List()))
    foreach(var item in quaternary)
    {
        //Whatever (Like: l.Add(item))
    }
}

Answer 3

从Troy Goode的PagedList库中无耻地窃取：https://github.com/TroyGoode/PagedList/blob/master/src/PagedList/PagedListExtensions.cs

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> superset, int pageSize)
{
  if (superset.Count() < pageSize)
    yield return superset;
  else
  {
    var numberOfPages = Math.Ceiling(superset.Count() / (double)pageSize);
    for (var i = 0; i < numberOfPages; i++)
      yield return superset.Skip(pageSize * i).Take(pageSize);  
  }
}

像这样使用它：

var result=myEnumerable.Partition(4);

Answer 4

如果您确实需要不可预测的结果（即随机），我建议使用以下算法：

创建列表中所有元素的随机排列。
将它们分成四倍。

对于第二部分，已经提供了许多好的答案。对于第一部分，有一个很棒的in-depth series on creating permutations with LINQ by Eric Lippert。

Answer 5

使用linq非常简单：

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> source, int batchSize)
{
    for (int i = 0; i < source.Count(); i+=batchSize)
    {
        yield return source.Skip(i).Take(batchSize);
    }
}

通过batchSize项分割列表，如果项目的数量不能按批量大小分割，则最后一次迭代将产生可枚举的剩余部分。

Linq将数据作为四元包获取

5 个答案: