Comment attendre en toute sécurité des événements asynchrones en C# ?

Gestion des événements asynchrones en C# : attendre en toute sécurité les opérations asynchrones

Aperçu du problème :

En C#, les événements sont généralement des délégués sans valeurs de retour qui sont utilisés pour informer les abonnés d'événements spécifiques dans l'application. Cependant, lorsque vous essayez d'utiliser un gestionnaire d'événements asynchrone, un problème peut survenir : l'événement est déclenché, mais l'application est fermée avant que le gestionnaire asynchrone ne termine son exécution.

Abonnez-vous aux événements à l'aide d'un gestionnaire asynchrone :

Afin de gérer les événements de manière asynchrone, il n'est pas recommandé de modifier la signature de l'événement elle-même pour renvoyer une tâche. Au lieu de cela, vous pouvez utiliser une méthode d'enregistrement qui accepte une fonction de rappel attendue. Cela offre une plus grande flexibilité et une intégration plus facile avec des composants tiers.

Mise en œuvre par méthode d'inscription :

<code class="language-csharp">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);
}</code>

Dans cet exemple, la liste ShutdownCallbacks stocke les fonctions de rappel qui peuvent être attendues. La méthode Shutdown() parcourt ces fonctions de rappel et les attend simultanément. Cela garantit que tous les gestionnaires asynchrones sont terminés avant que le processus d'arrêt ne continue.

Appelez l'événement à l'aide d'une liste d'appels :

Alternativement, si vous souhaitez conserver le paradigme d'événement existant, vous pouvez utiliser la méthode GetInvocationList() pour appeler les gestionnaires de manière séquentielle et attendre les tâches renvoyées.

<code class="language-csharp">class A
{
    public event Func<object, EventArgs, Task> Shutdown;

    public async Task OnShutdown()
    {
        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);
    }
}</code>

Ici, OnShutdown() récupère le délégué à l'événement, appelle les gestionnaires et attend leur achèvement.

Conclusion :

Bien que les gestionnaires d'événements asynchrones puissent sembler tentants, cette approche n'est généralement pas recommandée en raison du risque de blocages et d'autres problèmes. Comme mentionné ci-dessus, l'utilisation de méthodes enregistrées ou de listes d'appels fournit une solution plus robuste et plus facile à gérer pour les événements en attente asynchrone en C#.

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!