C# 分区IEnumerable<；T>；结果

我使用的方法处理时间很长，需要返回很多结果，但是正确的结果可能是任何一个返回的结果，比如说在300000个结果之后，剩余的700000个结果 返回是否正确将在主界面的以下代码中进行检查：

//a that suppose to return a value at need.
//Main func might need few returns and not all so 
static IEnumerable<int> foo() {
    //long recusive process, might contain over 1 million results if being asked to yield all.
    yield return ret;
}

static void Main(string[] args) {
    var a = foo();
    while (true) {
        var p = a.Take(300); //takes first 300 every loop in the while-loop
        foreach (var c in p) {
            //does something with it        
            if (bar == true) //if it is the right one:
                goto _break;            
        }
    }
    _break:
    Console.Read(); //pause
}

这将输出：

123123

，依此类推

答案付诸实践

类程序{
静态void Main（字符串[]参数）{
var j=0；
var a=新的EnumerationPartitioner（loly（）.GetEnumerator（））；
while（true）{
foreach（a.Pull（3）中的变量c）{
控制台写入线（c）；
Console.WriteLine（“（“+（++j）+”）；
}
如果（a）结束
打破
}
foreach（loly（）ToInMemoryBatches（7）中的var部分）{
foreach（部分为var c）{
控制台写入线（c）；
Console.WriteLine（“（“+（++j）+”）；
}
}
Console.Read（）；
}
静态IEnumerable loly（）{
var l=新[]{1,2,3,4,5,6,7,8,9}；
对于（int i=0；i<9；i++）{
收益率收益率l[i]；
}            
} 
}
//塔尔塞思法
公共静态类枚举分区器{
公共静态IEnumerable ToInMemoryBatches（此IEnumerable源，int batchSize）{
列表批次=空；
foreach（源中的var项）
{
如果（批==null）
批次=新列表（）；
批次。添加（项目）；
if（batch.Count！=batchSize）
继续；
退货批量；
批处理=空；
}
如果（批处理！=null）
退货批量；
}
}
//MarcinJuraszek法
公共类枚举分区器：IEnumerable{
/// 
///枚举结束了吗？
/// 
公众集会结束了{
获取{return over；}
}
公共IEnumerator枚举数{get；private set；}
公共枚举分区器（IEnumerator_enum）{
枚举数=_enum；
}
/// 
///枚举结束了吗
/// 
私有布尔覆盖=假；
/// 
///从数据库中提取的项目
/// 
私有整数n=0；
/// 
///将项目从列表中拉出。
/// 
///要从中拉出的项目数
公共列表拉取（整数计数）{
var l=新列表（）；
如果（超过）返回l；
对于（int i=0；i

您可以直接使用枚举器，而不是依赖于

foreach

循环：

static void Main(string[] args)
{
    var a = loly();
    var partitionSize = 3;

    using (var enumerator = a.GetEnumerator())
    {
        var values = new List<int>(partitionSize);
        for (int i = 0; i < 3; i++)
        {
            values.Clear();
            for (int j = 0; j < partitionSize && enumerator.MoveNext(); j++)
            {
                values.Add(enumerator.Current);
            }

            foreach (var c in values)
            {
                Console.Write(c);
            }
        }
    }

    Console.Read();
}

static void Main（字符串[]args）
{
var a=loly（）；
var partitionSize=3；
使用（var enumerator=a.GetEnumerator（））
{
var值=新列表（partitionSize）；
对于（int i=0；i<3；i++）
{
value.Clear（）；
对于（int j=0；j

我需要定期这样做。正如Alexei提到的，在处理这种形式的问题时，我一直想要一个枚举的枚举

    public static IEnumerable<IEnumerable<T>> ToInMemoryBatches<T>(this IEnumerable<T> source, int batchSize)
    {
        List<T> batch = null;
        foreach (var item in source)
        {
            if (batch == null)
                batch = new List<T>();

            batch.Add(item);

            if (batch.Count != batchSize)
                continue;

            yield return batch;
            batch = null;
        }

        if (batch != null)
            yield return batch;
    }

公共静态IEnumerable ToInMemoryBatches（此IEnumerable源代码，int batchSize）
{
列表批次=空；
foreach（源中的var项）
{
如果（批==null）
批次=新列表（）；
批次。添加（项目）；
if（batch.Count！=batchSize）
继续；
退货批量；
批处理=空；
}
如果（批处理！=null）
退货批量；
}

我提出了两种方法，不同之处在于分区大小不是固定的，一种是使用分区大小和其他分区结束索引，另外，如果最后一个分区未满，它将调整大小

    public static IEnumerable<T[]> PartitionBySize<T>(this IEnumerable<T> source, int[] sizes)
    {
        using (var iter = source.GetEnumerator())
            foreach (var size in sizes)
                if (iter.MoveNext())
                {
                    var chunk = new T[size];
                    chunk[0] = iter.Current;
                    int i = 1;
                    for (; i < size && iter.MoveNext(); i++)
                        chunk[i] = iter.Current;
                    if (i < size)
                        Array.Resize(ref chunk, i);
                    yield return chunk;
                }
                else
                    yield break;
    }

    public static IEnumerable<T[]> PartitionByIdx<T>(this IEnumerable<T> source, int[] indexes)
    {
        int last = -1;
        using (var iter = source.GetEnumerator())
            foreach (var idx in indexes)
            {
                int size = idx - last;
                last = idx;
                if (iter.MoveNext())
                {
                    var chunk = new T[size];
                    chunk[0] = iter.Current;
                    int i = 1;
                    for (; i < size && iter.MoveNext(); i++)
                        chunk[i] = iter.Current;
                    if (i < size)
                        Array.Resize(ref chunk, i);
                    yield return chunk;
                }
                else
                    yield break;
            }
    }

公共静态IEnumerable分区（此IEnumerable源代码，int[]大小）
{
使用（var iter=source.GetEnumerator（））
foreach（变量大小，以大小为单位）
if（iter.MoveNext（））
{
var chunk=新的T[大小]；
chunk[0]=iter.Current；
int i=1；
对于（；i    public static IEnumerable<IEnumerable<T>> ToInMemoryBatches<T>(this IEnumerable<T> source, int batchSize)
    {
        List<T> batch = null;
        foreach (var item in source)
        {
            if (batch == null)
                batch = new List<T>();

            batch.Add(item);

            if (batch.Count != batchSize)
                continue;

            yield return batch;
            batch = null;
        }

        if (batch != null)
            yield return batch;
    }

    public static IEnumerable<T[]> PartitionBySize<T>(this IEnumerable<T> source, int[] sizes)
    {
        using (var iter = source.GetEnumerator())
            foreach (var size in sizes)
                if (iter.MoveNext())
                {
                    var chunk = new T[size];
                    chunk[0] = iter.Current;
                    int i = 1;
                    for (; i < size && iter.MoveNext(); i++)
                        chunk[i] = iter.Current;
                    if (i < size)
                        Array.Resize(ref chunk, i);
                    yield return chunk;
                }
                else
                    yield break;
    }

    public static IEnumerable<T[]> PartitionByIdx<T>(this IEnumerable<T> source, int[] indexes)
    {
        int last = -1;
        using (var iter = source.GetEnumerator())
            foreach (var idx in indexes)
            {
                int size = idx - last;
                last = idx;
                if (iter.MoveNext())
                {
                    var chunk = new T[size];
                    chunk[0] = iter.Current;
                    int i = 1;
                    for (; i < size && iter.MoveNext(); i++)
                        chunk[i] = iter.Current;
                    if (i < size)
                        Array.Resize(ref chunk, i);
                    yield return chunk;
                }
                else
                    yield break;
            }
    }