4

我有一个运行的 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();
});

有任何想法吗？谢谢

4

4 回答 4

5

你可以使用AsParalleland 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()));
于 2012-04-17T15:27:41.677 回答
3

你可以尝试这样的事情，以更实用的风格：

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();
于 2012-04-17T15:26:58.010 回答
0

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 分配的每个工人初始化本地小计箱。第二个 lambda 表达式对集合中的每个项目执行一次，并更新本地小计 bin。第三个 lambda 表达式将局部小计箱合并到最终总数中。

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

于 2012-04-17T18:04:02.727 回答
0

当然，这完全有可能。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;
  });

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

于 2012-04-17T15:24:02.273 回答