C# 自定义条件并行。用于

我知道下面这句话

System.Threading.Tasks.Parallel.For(0, 5, (j, u) => {});

相等于

for (int j = 0; j < 5; j++){}

for（int j=0；j<5；j++）{

但是并行代码是用来做什么的呢

for (int i = 0; (i < x + y && i < z); i++)

for（inti=0；（i

并行。For

设计用于表示此类循环。它严格设计为表示从循环开始时已知的迭代次数

---

如果要使用它，您需要在调用

Parallel.For

之前计算所需的迭代次数。如果您不能合理地这样做，那么您将需要使用另一种并行化方法。

并行。因为

不是用来表示这种循环的。它严格设计为表示从循环开始时已知的迭代次数

---

如果要使用它，您需要在调用

Parallel.For

之前计算所需的迭代次数。如果您不能合理地这样做，那么您将需要使用另一种并行化方法。

并行。因为

不是用来表示这种循环的。它严格设计为表示从循环开始时已知的迭代次数

---

如果要使用它，您需要在调用

Parallel.For

之前计算所需的迭代次数。如果您不能合理地这样做，那么您将需要使用另一种并行化方法。

并行。因为

不是用来表示这种循环的。它严格设计为表示从循环开始时已知的迭代次数

---

如果要使用它，您需要在调用

Parallel.For

之前计算所需的迭代次数。如果您不能合理地这样做，那么您将需要使用另一种并行化方法。

听起来您真正想要的是一个并行的.While构造，它并不存在。您可以使用类似以下内容来近似功能：

public static void While( 
    ParallelOptions parallelOptions, Func<bool> condition, 
    Action<ParallelLoopState> body) 
{ 
    Parallel.ForEach(new InfinitePartitioner(), parallelOptions, 
        (ignored, loopState) => 
    { 
        if (condition()) body(loopState)); 
        else loopState.Stop(); 
    }); 
}

}}）

---

听起来你真正想要的是一个平行结构，而这个结构是不存在的。您可以使用类似以下内容来近似功能：

public static void While( 
    ParallelOptions parallelOptions, Func<bool> condition, 
    Action<ParallelLoopState> body) 
{ 
    Parallel.ForEach(new InfinitePartitioner(), parallelOptions, 
        (ignored, loopState) => 
    { 
        if (condition()) body(loopState)); 
        else loopState.Stop(); 
    }); 
}

}}）

---

听起来你真正想要的是一个平行结构，而这个结构是不存在的。您可以使用类似以下内容来近似功能：

public static void While( 
    ParallelOptions parallelOptions, Func<bool> condition, 
    Action<ParallelLoopState> body) 
{ 
    Parallel.ForEach(new InfinitePartitioner(), parallelOptions, 
        (ignored, loopState) => 
    { 
        if (condition()) body(loopState)); 
        else loopState.Stop(); 
    }); 
}

}}）

---

听起来你真正想要的是一个平行结构，而这个结构是不存在的。您可以使用类似以下内容来近似功能：

public static void While( 
    ParallelOptions parallelOptions, Func<bool> condition, 
    Action<ParallelLoopState> body) 
{ 
    Parallel.ForEach(new InfinitePartitioner(), parallelOptions, 
        (ignored, loopState) => 
    { 
        if (condition()) body(loopState)); 
        else loopState.Stop(); 
    }); 
}

}}）

---

就我个人而言，我会把条件分开，这样

for (int i = x; (i < x + y && i < z); i++)

for（inti=x；（i

变成

int n = z < x + y ? x + y : z;
System.Threading.Tasks.Parallel.For(x, n, (i) => { });

int n=z{}）的System.Threading.Tasks.Parallel.For（x，n，（i）=>{}）；

就个人而言，我会将条件分离出来，因此

for (int i = x; (i < x + y && i < z); i++)

for（inti=x；（i

变成

int n = z < x + y ? x + y : z;
System.Threading.Tasks.Parallel.For(x, n, (i) => { });

int n=z{}）的System.Threading.Tasks.Parallel.For（x，n，（i）=>{}）；

就个人而言，我会将条件分离出来，因此

for (int i = x; (i < x + y && i < z); i++)

for（inti=x；（i

变成

int n = z < x + y ? x + y : z;
System.Threading.Tasks.Parallel.For(x, n, (i) => { });

int n=z{}）的System.Threading.Tasks.Parallel.For（x，n，（i）=>{}）；

就个人而言，我会将条件分离出来，因此

for (int i = x; (i < x + y && i < z); i++)

for（inti=x；（i

变成

int n = z < x + y ? x + y : z;
System.Threading.Tasks.Parallel.For(x, n, (i) => { });

int n=z{}）的System.Threading.Tasks.Parallel.For（x，n，（i）=>{}）；

本案例不包括在内。只需在函数体中相应地退出代码。本例不包括在内。只需在函数体中相应地退出代码。本例不包括在内。只需在函数体中相应地退出代码。本例不包括在内。只需在函数体中相应地退出代码。请注意，这样的

条件

委托需要是线程安全的，这里的情况似乎不是这样，因为它基于当前迭代（无法真正安全访问的数据）。如果在前一次迭代完成之前，您不知道是否还会有另一次迭代，那么根本就没有什么可并行化的。请注意，这样的

条件

委托需要是线程安全的，这里的情况似乎不是这样，因为它是基于当前迭代的（无法真正安全访问的数据）。如果在前一次迭代完成之前您不知道是否还会有另一次迭代，那么根本就没有什么可并行化的。请注意，这样的

条件

委托需要是线程安全的，这里的情况似乎不是这样，因为它基于当前迭代（无法真正安全访问的数据）。如果在前一次迭代完成之前您不知道是否还会有另一次迭代，那么根本就没有什么可并行化的。请注意，这样的

条件

委托需要是线程安全的，这里的情况似乎不是这样，因为它基于当前迭代（无法真正安全访问的数据）。如果在上一次迭代完成之前您不知道是否还会有另一次迭代，那么就根本没有什么可并行化的。这假设

x

、

y

和

z

的值在循环开始之前都是已知的，并且在循环中从不更改。这假设

x

、

y和
z
在循环开始之前都是已知的，并且在循环中从不改变。这假设
x
、
y
和
z
的值在循环开始之前都是已知的，并且在循环中从不改变。这假设
x
、
y
和
z
的值在循环开始之前都是已知的在循环的开始，不要在循环中改变。