Comment gérer les événements asynchrones en C# ?

Explication détaillée du traitement des événements asynchrones C#

Présentation

Le mécanisme d'événements C# est un outil puissant pour gérer les opérations asynchrones. Cependant, les événements traditionnels sont nuls, ce qui rend impossible d’attendre la fin de leur exécution. Cet article explore plusieurs manières alternatives d’implémenter la gestion des événements asynchrones.

Défi

Considérez l'extrait de code suivant, où un événement d'arrêt doit être géré avec une tâche asynchrone :

public event EventHandler<EventArgs> GameShuttingDown;

public async Task ShutdownGame()
{
    // ...
    await this.NotifyGameShuttingDown();
    await this.SaveWorlds();
    this.NotifyGameShutDown();
    // ...
}

private async Task SaveWorlds()
{
    // ...
}

Le problème est que le gestionnaire d'événements NotifyGameShuttingDown est sans retour et son appel dans la méthode ShutdownGame empêchera la tâche de sauvegarde asynchrone de se terminer avant le déclenchement de l'événement.

Solution 1 : Délégation d'événements asynchrones personnalisée

Une solution consiste à définir un délégué d'événement personnalisé qui renvoie une tâche, permettant l'exécution du gestionnaire d'attente :

public event Func<object, EventArgs, Task> Shutdown;

Dans la méthode ShutdownGame, le gestionnaire peut être appelé comme ceci :

Func<object, EventArgs, Task> handler = Shutdown;

if (handler == null)
{
    return;
}

Delegate[] invocationList = handler.GetInvocationList();
Task[] handlerTasks = new Task[invocationList.Length];

for (int i = 0; i < invocationList.Length; i++)
{
    handlerTasks[i] = ((Func<object, EventArgs, Task>)invocationList[i])(this, EventArgs.Empty);
}

await Task.WhenAll(handlerTasks);

Solution 2 : Méthode basée sur l'inscription

Une autre option consiste à utiliser une approche basée sur l'enregistrement, dans laquelle les rappels peuvent être enregistrés et exécutés de manière asynchrone :

private List<Func<Task>> ShutdownCallbacks = new List<Func<Task>>();

public void RegisterShutdownCallback(Func<Task> callback)
{
    this.ShutdownCallbacks.Add(callback);
}

public async Task Shutdown()
{
    var callbackTasks = new List<Task>();
    foreach (var callback in this.ShutdownCallbacks)
    {
        callbackTasks.Add(callback());
    }

    await Task.WhenAll(callbackTasks);
}

Remarques

• Impact sur la conception : L'utilisation de gestionnaires d'événements asynchrones peut modifier la conception de votre application, alors réfléchissez attentivement à l'impact potentiel.
• Complexité : Les méthodes déléguées personnalisées ajoutent une complexité supplémentaire, mais elles garantissent la compatibilité avec les modèles d'événements existants.
• Performance : Une approche basée sur l'enregistrement peut être plus efficace car elle évite la surcharge de réflexion lors de l'appel des gestionnaires.

Recommandé

L'approche recommandée dépend des besoins spécifiques de l'application. Pour les bases de code existantes et les conceptions fortement basées sur des événements, les méthodes de délégation personnalisées sont préférées. Pour les nouvelles applications ou celles qui ne dépendent pas d’événements, une approche basée sur l’inscription peut offrir de meilleures performances et flexibilité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!