Comment puis-je convertir ce code foreach en Parallel.ForEach?

Je suis un peu confus Parallel.ForEach.
Qu'est- Parallel.ForEachce que c'est et que fait-il exactement?
Veuillez ne faire référence à aucun lien MSDN.

Voici un exemple simple:

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

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

Comment réécrire cet exemple avec Parallel.ForEach?

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

Boucle Foreach:

• Les itérations ont lieu séquentiellement, une par une
• La boucle foreach est exécutée à partir d'un seul thread.
• La boucle foreach est définie dans chaque framework de .NET
• L'exécution des processus lents peut être plus lente , car ils sont exécutés en série
  • Le processus 2 ne peut pas démarrer tant que 1 n'est pas terminé. Le processus 3 ne peut pas démarrer tant que 2 et 1 ne sont pas terminés ...
• L'exécution de processus rapides peut être plus rapide , car il n'y a pas de surcharge de thread

Parallel.ForEach:

• L'exécution a lieu de manière parallèle.
• Parallel.ForEach utilise plusieurs threads.
• Parallel.ForEach est défini dans les frameworks .Net 4.0 et supérieurs.
• L'exécution des processus lents peut être plus rapide , car ils peuvent être exécutés en parallèle
  • Les processus 1, 2 et 3 peuvent s'exécuter simultanément (voir les threads réutilisés dans l'exemple ci-dessous)
• L'exécution des processus rapides peut être plus lente , en raison de la surcharge de threading supplémentaire

L'exemple suivant montre clairement la différence entre la boucle foreach traditionnelle et

Exemple 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();
        }
    }
}

Production

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

Utilisation de l'exemple Parallel.ForEach

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
});

Cela entraînera l'analyse des lignes en parallèle, dans la boucle. Si vous voulez une introduction plus détaillée et moins "orientée référence" à la classe Parallel, j'ai écrit une série sur le TPL qui comprend une section sur Parallel.ForEach .

Pour les gros fichiers, utilisez le code suivant (vous avez moins besoin de mémoire)

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

Ces lignes ont fonctionné pour moi.

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