Comment rendre les événements C# asynchrones ?

Gestion élégante des événements asynchrones en C#

Dans une application C#, si une classe contient un événement (tel que l'événement 'GameShuttingDown') et que le gestionnaire d'événements est asynchrone, il peut y avoir un problème de fermeture du jeu avant la fin du gestionnaire d'événements en attente. En effet, l'événement lui-même est synchrone, mais le gestionnaire est asynchrone.

Bien qu'il soit possible d'utiliser des mécanismes asynchrones pour remplacer des événements, cela fera perdre la simplicité des événements. Une meilleure approche consiste à conserver l’expressivité des événements tout en permettant un traitement asynchrone. Nous pouvons le faire en personnalisant le type de délégué au lieu d'utiliser le standard EventHandler.

L'exemple suivant montre comment :

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

    public async Task OnShutdown()
    {
        var handler = Shutdown;

        if (handler == null)
        {
            return;
        }

        var invocationList = handler.GetInvocationList();
        var handlerTasks = invocationList.Select(h => ((Func<object, EventArgs, Task>)h)(this, EventArgs.Empty)).ToArray();

        await Task.WhenAll(handlerTasks);
    }
}</code>

Dans la méthode OnShutdown(), nous obtenons d'abord une copie locale du délégué à l'événement. Nous appelons ensuite tous les gestionnaires et stockons les tâches renvoyées dans un tableau. Enfin, nous utilisons Task.WhenAll() pour attendre que toutes les tâches soient terminées. C'est plus concis que l'itération en boucle.

Ce qui suit est un programme de console simple qui démontre son utilisation :

<code class="language-csharp">public class Program
{
    public static void Main(string[] args)
    {
        var a = new A();

        a.Shutdown += Handler1;
        a.Shutdown += Handler2;
        a.Shutdown += Handler3;

        a.OnShutdown().Wait();
    }

    public static async Task Handler1(object sender, EventArgs e)
    {
        Console.WriteLine("启动关闭处理程序 #1");
        await Task.Delay(1000);
        Console.WriteLine("关闭处理程序 #1 完成");
    }

    public static async Task Handler2(object sender, EventArgs e)
    {
        Console.WriteLine("启动关闭处理程序 #2");
        await Task.Delay(5000);
        Console.WriteLine("关闭处理程序 #2 完成");
    }

    public static async Task Handler3(object sender, EventArgs e)
    {
        Console.WriteLine("启动关闭处理程序 #3");
        await Task.Delay(2000);
        Console.WriteLine("关闭处理程序 #3 完成");
    }
}</code>

Cette approche conserve la simplicité des événements tout en garantissant que les gestionnaires s'exécutent de manière asynchrone, évitant ainsi les problèmes de blocage synchrone. L'utilisation de la méthode Select de LINQ simplifie le code, le rendant plus facile à lire et à maintenir.

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!