De la tâche.WaitAll méthode vs Parallèle.Méthode Invoke

J'ai un exemple de code pour comparer les temps de traitement en Parallèle de l'approche et de l'approche de la Tâche. Le but de cette expérience est de comprendre comment fonctionnent-ils.

Donc mes questions sont:

1. Pourquoi Parallèle travaillé plus rapide, puis la Tâche?
2. Faire de mon résultat signifie que je dois utiliser en Parallèle au lieu de la Tâche?
3. Où dois-je utiliser les groupes de travail et où Parallèle?
4. Quels sont les avantages de l'utilisation de la Tâche en comparaison Parallèle?

5. Ne Tâche est juste une enveloppe pour le pool de threads.QueueUserWorkItem méthode?

       public Task SomeLongOperation()
       {
           return Task.Delay(3000);
       }
   
       static void Main(string[] args)
       {
           Program p = new Program();
           List<Task> tasks = new List<Task>();
   
           tasks.Add(Task.Factory.StartNew(() => p.SomeLongOperation()));
           tasks.Add(Task.Factory.StartNew(() => p.SomeLongOperation()));
   
           var arr = tasks.ToArray();
   
           Stopwatch sw = Stopwatch.StartNew();
           Task.WaitAll(arr);
           Console.WriteLine("Task wait all results: " + sw.Elapsed);
           sw.Stop();
   
           sw = Stopwatch.StartNew();
           Parallel.Invoke(() => p.SomeLongOperation(), () => p.SomeLongOperation());
           Console.WriteLine("Parallel invoke results: " + sw.Elapsed);
           sw.Stop();
   
           Console.ReadKey();
       }

Voici mes résultats du traitement:

EDIT:

Code modifié pour ressembler à ceci:

    Program p = new Program();
    Task[] tasks = new Task[2];

    Stopwatch sw = Stopwatch.StartNew();
    tasks[0] = Task.Factory.StartNew(() => p.SomeLongOperation());
    tasks[1] = Task.Factory.StartNew(() => p.SomeLongOperation());

    Task.WaitAll(tasks);
    Console.WriteLine("Task wait all results: " + sw.Elapsed);
    sw.Stop();

    sw = Stopwatch.StartNew();
    Parallel.Invoke(() => p.SomeLongOperation(), () => p.SomeLongOperation());
    Console.WriteLine("Parallel invoke results: " + sw.Elapsed);
    sw.Stop();

Mes nouveaux résultats:

EDIT 2:
Quand j'ai remplacé le code en Parallèle.Invoquer pour être la première et Tâche.WaitAll d'être le second, la situation a changé foncièrement. Maintenant Parallèle est plus lent. Il me fait penser à l'inexactitude de mes estimations. J'ai changé le code ressemble à ceci:

Program p = new Program();
Task[] tasks = new Task[2];

Stopwatch sw = null;
for (int i = 0; i < 10; i++)
{
    sw = Stopwatch.StartNew();
    Parallel.Invoke(() => p.SomeLongOperation(), () => p.SomeLongOperation());
    string res = sw.Elapsed.ToString();
    Console.WriteLine("Parallel invoke results: " + res);
    sw.Stop();
}

for (int i = 0; i < 10; i++)
{
    sw = Stopwatch.StartNew();
    tasks[0] = Task.Factory.StartNew(() => p.SomeLongOperation());
    tasks[1] = Task.Factory.StartNew(() => p.SomeLongOperation());
    Task.WaitAll(tasks);
    string res2 = sw.Elapsed.ToString();
    Console.WriteLine("Task wait all results: " + res2);
    sw.Stop();
}

Et voici mes nouveaux résultats:

Maintenant je peux suggérer que cette expérience est beaucoup plus clair. Les résultats sont presque les mêmes. Parfois Parallèle, et parfois la Tâche est plus rapide. Maintenant mes questions sont:

1. Où dois-je utiliser les groupes de travail et où Parallèle?

2. Quels sont les avantages de l'utilisation de la Tâche en comparaison Parallèle?

3. Ne Tâche est juste une enveloppe pour le pool de threads.QueueUserWorkItem méthode?

Toute info utile qui peut aider à clarifier ces questions sont les bienvenues.