C# 使用Ienumerable.TakeWhile，但只返回一组结果

首先，如果我的代码不好或者描述不好，我想道歉。这是我第一次使用C#线程/任务。我在代码中尝试做的是遍历一个名称列表，对于列表中的每50个名称，启动一个新任务，并将这50个名称传递给另一个方法，该方法将对数据执行计算量大的方法。我的代码只对列表中的前50个名字起作用，每隔一次返回0个结果，我似乎不知道为什么

public static async void startInitialDownload(string value)
    {
        IEnumerable<string> names = await Helper.getNames(value, 0);
        decimal multiple = names.Count() / 50;
        string[] results;
        int num1 = 0;
        int num2 = 0;

        for (int i = 0; i < multiple + 1; i++)
        {
            num1 = i * 50;
            num2 = (50 * (i + 1));
            results = names.TakeWhile((name, index) => index >= num1 && index < num2).ToArray();
            Task current = Task.Factory.StartNew(() => getCurrentData(results));
            await current.ConfigureAwait(false);
        }
    }

公共静态异步void startInitialDownload（字符串值）
{
IEnumerable names=wait Helper.getNames（值为0）；
十进制倍数=名称。计数（）/50；
字符串[]结果；
int num1=0；
int num2=0；
对于（int i=0；iindex>=num1&&indexgetCurrentData（结果））；
等待当前。配置等待（false）；
}
}

名称

TakeWhile

表明它仅在条件为true时接受条目。因此，如果它从读取一个条件为false的条目开始，它永远不会接受任何东西

第一个循环，从

num1

=0开始。因此，它将条目从

num1

读取到

num2

第二个循环，从

num1

为51开始。所以它又开始阅读了。。。当它第一次进入时，条件为false，因此它停止

您可以尝试使用

Where

，或者在开始之前使用

Skip

---

tl；博士关于它：我不认为您的问题与并行任务有关，我认为这是由于使用了错误的LINQ方法来提取您想要使用的名称。

正如我从Stephen Cleary对类似（尽管不完全相同）问题的回答中所理解的，您不需要在那里使用ConfigureWait（）

以下是相关链接：

下面是我将用for循环的最后两行来做的：

Task.Factory.StartNew(() => getCurrentData(results));

就这样。通过使用工厂，而不是等待，您可以让该任务自行运行（可能在新线程上）。如果您的存储都是线程安全的（请参阅：

System.Collections.Concurrent

btw），那么您应该都已设置好

---

警告：如果您在等待之后没有向我们展示什么，那么您的结果可能会有所不同。

这不是一个直接的解决方案，但可能有效

public static IEnumerable<T[]> MakeBuckets<T>(IEnumerable<T> source, int maxSize)

    {
        List<T> currentBucket = new List<T>(maxSize);

        foreach (var s in source)
        {
            currentBucket.Add(s);
            if (currentBucket.Count >= maxSize)
            {
                yield return currentBucket.ToArray();
                currentBucket = new List<T>(maxSize);

            }

        }
        if(currentBucket.Any())
            yield return currentBucket.ToArray();
    }

公共静态IEnumerable makebucket（IEnumerable源代码，int-maxSize）
{
List currentBucket=新列表（maxSize）；
foreach（源中的var s）
{
currentBucket.Add（s）；
如果（currentBucket.Count>=maxSize）
{
收益返回currentBucket.ToArray（）；
currentBucket=新列表（maxSize）；
}
}
if（currentBucket.Any（））
收益返回currentBucket.ToArray（）；
}

---

稍后，您可以迭代MakeBucket函数的结果。

将可枚举项实现为一个列表，以便只计算一次，而不是循环中的每次迭代。您可以使用

Skip

和

Take

方法获取列表的范围：

public static async void startInitialDownload(string value) {
  IEnumerable<string> names = await Helper.getNames(value, 0);
  List<string> nameList = names.ToList();
  for (int i = 0; i < nameList.Count; i += 50) {
    string[] results = nameList.Skip(i).Take(50).ToArray();
    Task current = Task.Factory.StartNew(() => getCurrentData(results));
    await current.ConfigureAwait(false);
  }
}

公共静态异步void startInitialDownload（字符串值）{
IEnumerable names=wait Helper.getNames（值为0）；
List name List=names.ToList（）；
对于（int i=0；igetCurrentData（结果））；
等待当前。配置等待（false）；
}
}

或者，您可以将项目添加到列表中，并在其大小合适时执行该列表：

public static async void startInitialDownload(string value) {
  IEnumerable<string> names = await Helper.getNames(value, 0);
  List<string> buffer = new List<string>();
  foreach (string s in names) {
    buffer.Add(s);
    if (buffer.Count == 50) {
      Task current = Task.Factory.StartNew(() => getCurrentData(buffer.ToArray()));
      await current.ConfigureAwait(false);
      buffer = new List<string>();
    }
  }
  if (buffer.Count > 0) {
    Task current = Task.Factory.StartNew(() => getCurrentData(buffer.ToArray()));
    await current.ConfigureAwait(false);
  }
}

公共静态异步void startInitialDownload（字符串值）{
IEnumerable names=wait Helper.getNames（值为0）；
列表缓冲区=新列表（）；
foreach（名称中的字符串s）{
缓冲区。添加（s）；
如果（buffer.Count==50）{
当前任务=Task.Factory.StartNew（（）=>getCurrentData（buffer.ToArray（））；
等待当前。配置等待（false）；
buffer=新列表（）；
}
}
如果（buffer.Count>0）{
当前任务=Task.Factory.StartNew（（）=>getCurrentData（buffer.ToArray（））；
等待当前。配置等待（false）；
}
}