Même si vous débutez en C#, vous avez probablement rencontré au moins une tâche, un thread ou un backgroundworker. Avec un peu de temps supplémentaire, il est probable que vous ayez vu les trois dans votre voyage. Ce sont tous des moyens d’exécuter du code simultané en C # et chacun a son propre ensemble d’avantages et d’inconvénients. Dans cet article, nous allons explorer comment chacun fonctionne à un niveau élevé. Il convient de noter que dans la plupart des applications et bibliothèques .NET modernes, vous verrez des éléments converger vers les tâches.
L’approche
Je suis allé de l’avant et j’ai créé une application de test que vous pouvez trouver ici. Parce que c’est dans le contrôle de source, il est possible/probable qu’il diverge de ce que nous voyons dans cet article, donc je voulais juste offrir cela comme une clause de non-responsabilité pour vous en tant que lecteur.
L’application nous permet de sélectionner différents exemples à exécuter. Je vais commencer par coller ce code ci-dessous afin que vous puissiez voir comment les choses fonctionnent.
using System.Globalization;
internal sealed class Program
{
private static readonly IReadOnlyDictionary<int, IExample> _examples =
new Dictionary<int, IExample>()
{
[1] = new NonBackgroundThreadExample(),
[2] = new BackgroundThreadExample(),
[3] = new BackgroundWorkerExample(),
[4] = new SimultaneousExample(),
};
private static void Main(string[] args)
{
Console.WriteLine("Enter the number for one of the following examples to run:");
foreach (var entry in _examples)
{
Console.WriteLine("----");
var restoreColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine($"Choice: {entry.Key}");
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine($"Name: {entry.Value.Name}");
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Description: {entry.Value.Description}");
Console.ForegroundColor = restoreColor;
}
Console.WriteLine("----");
IExample example;
while (true)
{
var input = Console.ReadLine();
if (string.IsNullOrWhiteSpace(input))
{
Console.WriteLine("Would you like to exit? Y/N");
input = Console.ReadLine();
if ("y".Equals(input, StringComparison.OrdinalIgnoreCase))
{
return;
}
Console.WriteLine("Please make another selection.");
continue;
}
if (!int.TryParse(input, NumberStyles.Integer, CultureInfo.InvariantCulture, out var exampleId) ||
!_examples.TryGetValue(exampleId, out example))
{
Console.WriteLine("Invalid input. Please make another selection.");
continue;
}
break;
}
Console.WriteLine($"Starting example '{example.Name}'...");
Console.WriteLine("-- Before entering example method");
example.ExecuteExample();
Console.WriteLine("-- After leaving example method");
}
}
Fils
Les threads sont la forme la plus basique d’exécution simultanée en C#. Ils sont créés et gérés par le système d’exploitation et peuvent être utilisés pour exécuter du code en parallèle avec le fil d’exécution principal. Le concept de thread est l’un des éléments de base les plus élémentaires lorsque nous parlons de concurrence en général pour la programmation. Cependant, c’est aussi le nom d’une classe que nous pouvons directement utiliser en C# pour exécuter du code concurrent.
Les threads permettent de passer une méthode à exécuter. Ils peuvent également être marqués comme arrière-plan ou non, où un thread d’arrière-plan sera tué lorsque l’application tentera de se fermer. À l’inverse, un thread qui n’est pas en arrière-plan tentera de maintenir l’application en vie jusqu’à ce que le thread se termine.
Voici un exemple de création et de démarrage d’un nouveau fil :
Thread newThread = new Thread(new ThreadStart(MyMethod));
newThread.Start();
L’un des principaux avantages de l’utilisation de Threads est qu’ils ont un faible temps système, car ils sont gérés directement par le système d’exploitation. Cependant, ils peuvent être plus difficiles à utiliser que d’autres options simultanées, car ils n’ont pas de prise en charge intégrée pour l’annulation, les rapports de progression ou la gestion des exceptions. En C #, nous avons accès à l’objet Thread depuis longtemps, il est donc logique que d’autres constructions aient été construites en plus de cela pour nous, ajoutant des améliorations supplémentaires à la qualité de vie.
Voyons le premier exemple de Thread :
public void ExecuteExample()
{
void DoWork(string label)
{
while (true)
{
Task.Delay(1000).Wait();
Console.WriteLine($"Waiting in '{label}'...");
}
};
var thread = new Thread(new ThreadStart(() => DoWork("thread")));
thread.Start();
Console.WriteLine("Press enter to exit!");
Console.ReadLine();
}
Dans le contexte de notre exemple d’application, nous pourrions voir la méthode s’imprimer sur la console pendant que le Thread est en cours d’exécution. Cependant, lorsque l’utilisateur appuie sur Entrée, l’exemple de méthode se ferme, puis le programme essaie également de se fermer. Parce que ce fil n’est pas marqué comme arrière-plan, il empêchera en fait l’application de se terminer naturellement ! Essayez-le et voyez.
Nous pouvons directement comparer cela avec le deuxième exemple, qui a une différence : le Thread est marqué comme arrière-plan. Lorsque vous essayez cet exemple, vous remarquerez que le thread en cours d’exécution n’empêche pas l’application de se fermer !
Travailleurs en arrière-plan
BackgroundWorker est une option d’exécution simultanée de niveau supérieur en C#. C’est un composant inclus dans l’espace de noms System.ComponentModel, et généralement vous le voyez utilisé dans les applications GUI. Par exemple, les applications WinForms classiques en tireraient parti.
Regardons notre exemple pour BackgroundWorker :
public void ExecuteExample()
{
void DoWork(string label)
{
while (true)
{
Task.Delay(1000).Wait();
Console.WriteLine($"Waiting in '{label}'...");
}
};
var backgroundWorker = new BackgroundWorker();
// NOTE: RunWorkerCompleted may not have a chance to run before the application exits
backgroundWorker.RunWorkerCompleted += (s, e) => Console.WriteLine("Background worker finished.");
backgroundWorker.DoWork += (s, e) => DoWork("background worker");
backgroundWorker.RunWorkerAsync();
Console.WriteLine("Press enter to exit!");
Console.ReadLine();
}
L’un des principaux avantages de l’utilisation d’un BackgroundWorker est qu’il dispose d’un support intégré pour l’annulation, les rapports de progression et la gestion des exceptions. Sa configuration est légèrement différente dans la mesure où les gestionnaires d’événements sont enregistrés sur le BackgroundWorker. Vous pouvez également avoir un gestionnaire d’achèvement et d’autres enregistrés dans l’objet. Comme un Thread marqué comme arrière-plan, le BackgroundWorker n’empêchera pas l’application de se fermer.
Tâches
Vous voulez voir comment les tâches sont prises en compte ? Assurez-vous de consulter mon article de blog qui détaille les tâches de la même manière. Il résume avec une conclusion sur la façon dont vous voudrez peut-être utiliser chacun dans vos programmes !