Правильно используя .AsParallel() эффективно с помощью LINQ

Question

У меня есть кортеж, и я итерация над ним с помощью LINQ

List<Tuple<string[], double[]>> tt = new List<Tuple<string[], double[]>>(); 

var t1 = new Tuple<string[], double[]>(
    new string[] { "java", "c#", "nn" }, 
    new double[] { 2, 3, 0 }); 

var t2 = new Tuple<string[], double[]>(
    new string[] { "java", "c#", "nn" }, 
    new double[] { 0, 3, 1 }); 

var t3 = new Tuple<string[], double[]>(
    new string[] { "java", "c#", "nn" }, 
    new double[] { 2, 1, 0 }); 

tt.Add(t1); 
tt.Add(t2); 
tt.Add(t3); 

var XX = (from tuples in tt 
      let rows = tuples.Item2.ToArray() 
      let result = rows.Select(x => x/rows.Count(i => i != 0)).ToArray() 
     select new Tuple<string[], double[]>(tuples.Item1, result) 
     ).ToList(); 

Если я хочу использовать .Asparallel я могу сделать один из следующих способов:

я добавил его, когда цикл по списку:

 var XX = (from tuples in tt 
        .AsParallel() //Parallel added here 
        let rows = tuples.Item2.ToArray() 
        let result = rows.Select(x => x/rows.Count(i => i != 0)).ToArray() 
       select new Tuple<string[], double[]>(tuples.Item1, result) 
       ).ToList(); 

я могу добавить его при преобразовании материала с помощью .ToArray() или .ToList

 var XX = (from tuples in tt 

        let rows = tuples.Item2.ToArray() 
        let result = rows.Select(x => x/rows.Count(i => i != 0)).AsParallel().ToArray() //Parallel added right here 
       select new Tuple<string[], double[]>(tuples.Item1, result) 
       ).ToList(); 

Что является наиболее эффективным способом использования .Asparallel? Все эти методы не дают ошибок, но я не уверен, что они влияют на производительность.

И добавляет .Asparallel как это плохая идея ?:

 var XX = (from tuples in tt 
        .AsParallel() //added here 
        let rows = tuples.Item2.AsParallel().ToArray() //here 
        let result = rows.Select(x => x/rows.Count(i => i != 0)).AsParallel().ToArray()//here 
       select new Tuple<string[], double[]>(tuples.Item1, result) 
       ).AsParallel().ToList(); // and here 

Answer 1

Вы должны добавить AsParallel при запуске запроса LINQ, в from пункте. Это приведет к тому, что оба оператора let будут выполняться параллельно, а затем вместе, когда вызывается ToList в конце.

Вы также можете добавить еще AsParallel перед вызовом Select внутри запроса.

var XX = (from tuples in tt.AsParallel() 
      let rows = tuples.Item2.ToArray() 
      let result = rows.AsParallel().Select(x => x/rows.Count(i => i != 0)).ToArray() 
     select new Tuple<string[], double[]>(tuples.Item1, result) 
     ).ToList(); 

Однако следует помнить, что AsParallel имеют некоторые накладные расходы поэтому в некоторых случаях это может быть медленнее, чем обычная, без параллельной обработки. Зависит от количества элементов и того, насколько дорого стоит вычисление.