Question

我有一个运行的foreach循环。我正在研究并行功能。是否可以转换以下代码以使用并行编程？

int result ;
int counter;
foreach(DataRow dr in ds.Tables[0].Rows) {
    switch(dr["Gender"].ToString()) {
        case "Male":
            result = functionMale(dr["Gender"].ToString());
            counter += result;
            break;
        case "Female":
            result = functionFemale(dr["Gender"].ToString());
            counter += result;
            break;
        default:
            result = functionUnkown(dr["Gender"].ToString());
            counter += result;
            break;
    }
}

根据我的观察，到目前为止我只有以下内容。

Parallel.ForEach(ds.Tables[0].AsEnumerable(), dr => {
    var result = functionMale(dr["Gender"].ToString();
});

有什么想法吗？感谢

Answer 1

您可以使用AsParallel和Sum：

Func<string, int> calculateGender =
    gender =>
    {
        // nb: I don't know why you pass the gender to the method, but
        // I've left your intent as-is
        switch (gender)
        {
            case "Male":   return functionMale(gender);
            case "Female": return functionFemale(gender);
            default:       return functionUnknown(gender);
        }
    };

int counter = ds.Tables[0].AsEnumerable()
                          .AsParallel()
                          .Sum(dr => calculateGender(dr["Gender"].ToString()));

Answer 2

您可以尝试使用更具功能性的风格：

var counter = 
    ds.Tables[0].AsEnumerable()
    .AsParallel()
    .Select( dr => {
        var gender = dr["Gender"].ToString();

        switch(gender) 
        {
            case "Male":
                return functionMale(gender);
            case "Female":
                return functionFemale(gender);
            default:
                return functionUnkown(gender);
        }
    })
    .Sum();

Answer 3

当然，这完全有可能。 Parallel.ForEach在这个实例中没有做任何特定的魔法（除了线程），所以它看起来像这样：

ds.Tables[0].Rows.AsEnumerable().AsParallel().Sum(x =>
  {
       DataRow dr = x as DataRow;

       switch(dr["Gender"].ToString())
       {
           case "Male":
             // Stuff
           case "Female";
             // Stuff
           default:
             // Stuff
       }

       return counter;
  });

这应该聚合函数的所有值，因为加法是可交换的。

Answer 4

PLINQ方法要容易得多，但只是为了完善这里的答案，你将如何使用Parallel.ForEach来实现这一目标。

int counter = 0;
Parallel.ForEach(ds.Tables[0].AsEnumerable(),
  () => /* subtotal initializer */
  {
    return 0; 
  },
  (dr, state, subtotal) => /* loop body */
  {
    switch(dr["Gender"].ToString()) 
    { 
        case "Male": 
            subtotal += functionMale(dr["Gender"].ToString()); 
            break; 
        case "Female": 
            subtotal += functionFemale(dr["Gender"].ToString()); 
            break; 
        default: 
            subtotal += functionUnkown(dr["Gender"].ToString()); 
            break; 
    }
  },
  subtotal => /* subtotal accumulator */
  {
    Interlocked.Add(ref counter, subtotal);
  });

这是如何工作的。第一个lambda表达式初始化TPL发出的每个worker的本地小计箱。第二个lambda表达式对集合中的每个项执行一次，并更新本地小计bin。第三个lambda表达式将局部小计分箱组合成最终总分。

使用Parallel.ForEach和AsParallel与聚合之间的一个有趣区别在于小计被累积到最终值的方式。 Parallel.ForEach在工作线程上执行此操作，因此需要线程安全操作Interlocked.Add。 AsParallel使用相同的分区策略，但会在调用者线程上累积小计。

我可以使用parallel.ForEach来调用不同的函数吗？

4 个答案: