Come posso convertire questo codice foreach in Parallel.ForEach?

Sono un po 'confuso Parallel.ForEach.
Che cos'è Parallel.ForEache cosa fa esattamente?
Si prega di non fare riferimento a nessun collegamento MSDN.

Ecco un semplice esempio:

string[] lines = File.ReadAllLines(txtProxyListPath.Text);
List<string> list_lines = new List<string>(lines);

foreach (string line in list_lines)
{
    //My Stuff
}

Come posso riscrivere questo esempio con Parallel.ForEach?

string[] lines = File.ReadAllLines(txtProxyListPath.Text);
List<string> list_lines = new List<string>(lines);
Parallel.ForEach(list_lines, line =>
{
    //Your stuff
});

Foreach loop:

• Le iterazioni si svolgono in sequenza, una per una
• il ciclo foreach viene eseguito da un singolo thread.
• foreach loop è definito in ogni framework di .NET
• L'esecuzione di processi lenti può essere più lenta , poiché vengono eseguiti in serie
  • Il processo 2 non può iniziare fino al termine di 1. Il processo 3 non può iniziare fino al completamento di 2 e 1 ...
• L'esecuzione di processi rapidi può essere più veloce , poiché non vi è alcun overhead di threading

Parallel.ForEach:

• L'esecuzione avviene in modo parallelo.
• Parallel.ForEach utilizza più thread.
• Parallel.ForEach è definito in framework .Net 4.0 e versioni successive.
• L'esecuzione di processi lenti può essere più veloce , poiché possono essere eseguiti in parallelo
  • I processi 1, 2 e 3 possono essere eseguiti contemporaneamente (vedere i thread riutilizzati nell'esempio di seguito)
• L'esecuzione di processi rapidi può essere più lenta , a causa dell'overhead di threading aggiuntivo

L'esempio seguente dimostra chiaramente la differenza tra il ciclo foreach tradizionale e

Esempio di Parallel.ForEach ()

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
namespace ParallelForEachExample
{
    class Program
    {
        static void Main()
        {
            string[] colors = {
                                  "1. Red",
                                  "2. Green",
                                  "3. Blue",
                                  "4. Yellow",
                                  "5. White",
                                  "6. Black",
                                  "7. Violet",
                                  "8. Brown",
                                  "9. Orange",
                                  "10. Pink"
                              };
            Console.WriteLine("Traditional foreach loop\n");
            //start the stopwatch for "for" loop
            var sw = Stopwatch.StartNew();
            foreach (string color in colors)
            {
                Console.WriteLine("{0}, Thread Id= {1}", color, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(10);
            }
            Console.WriteLine("foreach loop execution time = {0} seconds\n", sw.Elapsed.TotalSeconds);
            Console.WriteLine("Using Parallel.ForEach");
            //start the stopwatch for "Parallel.ForEach"
             sw = Stopwatch.StartNew();
            Parallel.ForEach(colors, color =>
            {
                Console.WriteLine("{0}, Thread Id= {1}", color, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(10);
            }
            );
            Console.WriteLine("Parallel.ForEach() execution time = {0} seconds", sw.Elapsed.TotalSeconds);
            Console.Read();
        }
    }
}

Produzione

Traditional foreach loop
1. Red, Thread Id= 10
2. Green, Thread Id= 10
3. Blue, Thread Id= 10
4. Yellow, Thread Id= 10
5. White, Thread Id= 10
6. Black, Thread Id= 10
7. Violet, Thread Id= 10
8. Brown, Thread Id= 10
9. Orange, Thread Id= 10
10. Pink, Thread Id= 10
foreach loop execution time = 0.1054376 seconds

Usando Parallel.ForEach esempio

1. Red, Thread Id= 10
3. Blue, Thread Id= 11
4. Yellow, Thread Id= 11
2. Green, Thread Id= 10
5. White, Thread Id= 12
7. Violet, Thread Id= 14
9. Orange, Thread Id= 13
6. Black, Thread Id= 11
8. Brown, Thread Id= 10
10. Pink, Thread Id= 12
Parallel.ForEach() execution time = 0.055976 seconds

string[] lines = File.ReadAllLines(txtProxyListPath.Text);

// No need for the list
// List<string> list_lines = new List<string>(lines); 

Parallel.ForEach(lines, line =>
{
    //My Stuff
});

Questo farà sì che le linee vengano analizzate in parallelo, all'interno del loop. Se vuoi un'introduzione più dettagliata, meno "orientata al riferimento" alla classe Parallel, ho scritto una serie sul TPL che include una sezione su Parallel.ForEach .

Per file di grandi dimensioni, utilizzare il codice seguente (si ha meno memoria)

Parallel.ForEach(File.ReadLines(txtProxyListPath.Text), line => {
    //Your stuff
});

Queste linee hanno funzionato per me.

string[] lines = File.ReadAllLines(txtProxyListPath.Text);
var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 10 };
Parallel.ForEach(lines , options, (item) =>
{
 //My Stuff
});