Question

我在数组中有100万个元素，我需要将这些元素分成100个组，执行一个函数并继续处理下一个百元

foreach (string value in lines)
{
    filescreated++;
    if (filescreated == ?????????)
    {
        do stuff 
    }
}

????等于可被100整除的值

Answer 1

等于可除以100的值

foreach (...)
{
    filescreated++;

    if (filescreated % 100 == 0) 
    {
        // do stuff for the every 100th element
    }

    // do other stuff for every element
}

参考：modulus (%) operator

如果您需要为每100个元素执行一些特殊操作，请使用此方法，但仍需要处理每个元素。

如果您只需要处理每100个元素，请参阅Reed的答案。

Answer 2

这个怎么样（如果你需要按顺序而％对你不好）？

当你谈论每一百个元素，然后是大约100个元素之后，这个问题很混乱。所以这里有一个猜测。

        string[] lines = new string[1000000];
        for (int i = 0; i < 10000; i++)
        {
            for (int j = 0; j < 100; j++)
            {
                DoSomething(lines[100*i + j], i);
            }
        }

Answer 3

我需要将这些元素分成100个组，执行一个函数并继续处理下一个

你可以直接这样做，如果这是一个数组，只需使用for循环并递增100：

int chunkSize = 100;

for (int start=0; start<lines.Length;start += chunkSize)
{        
    ProcessSectionOfArray(lines, start, Math.Min(start+chunkSize-1, lines.Length-1));
}

Answer 4

这是一个将分区逻辑分离为单独函数的解决方案。

    // A separate static function
    private static IEnumerable<IEnumerable<T>> BreakIntoBlocks<T>(T[] source, int blockSize)
    {
        for (int i = 0; i < source.Length; i += blockSize)
        {
            yield return source.Skip(i).Take(blockSize);
        }
    }


    // And in your code

    string[] lines = new string[1000000];
    foreach(IEnumerable<string> stringBlock in BreakIntoBlocks(lines, 100))
    {
            // stringblock is a block of 100 elements
            // Here is where you put the code that processes each separate group
    }

上述尝试应该比我的第一次尝试（下面）

更快

        int blockSize = 100;
        int i = 0;
        IEnumerable<IEnumerable<string>> query = from s in lines
                                                let num = i++
                                                group s by num / blockSize into g
                                                select g;
        foreach(IEnumerable<string> stringBlock in query)
        {
            // Stringblock will be a block of 100 elements.
            // Process this 100 elements here.
        }

使用分组子句的问题是LINQ会在返回第一个元素之前将这1000000个元素中的每一个分配给组。

为数组中的每第100个元素执行一些操作

4 个答案: