Comment puis-je créer des gestionnaires d'événements attendus en C# pour la sauvegarde asynchrone des données avant l'arrêt de l'application ?

Implémentation du gestionnaire d'événements asynchrones en C#

Problème : Gestion des événements attendus

Dans une application C#, vous pouvez être confronté à un défi : exiger que les gestionnaires d'événements waitable garantissent que les tâches de sauvegarde de données asynchrones sont terminées avant la fermeture de l'application. Actuellement, la nature synchrone de l'événement entraîne la fermeture du jeu avant que la sauvegarde asynchrone ne soit terminée.

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

L'approche recommandée consiste à créer un délégué d'événement personnalisé qui renvoie une tâche au lieu de void. De cette façon, vous pouvez attendre les gestionnaires et vous assurer qu'ils ont terminé avant de continuer.

Réussite

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

    public async Task Shutdown()
    {
        Func<object, EventArgs, Task> handler = GameShuttingDown;

        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>

Exemples d'utilisation

<code class="language-csharp">Game game = new Game();

game.GameShuttingDown += async (sender, args) => await SaveUserData();

await game.Shutdown();</code>

Alternative : inscrivez-vous et appelez explicitement

Une autre option consiste à enregistrer les rappels et à les appeler explicitement en cas de besoin.

<code class="language-csharp">class Game
{
    private List<Func<Task>> _shutdownCallbacks = new List<Func<Task>>();

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

    public async Task Shutdown()
    {
        var callbackTasks = new List<Task>();

        foreach (var callback in _shutdownCallbacks)
        {
            callbackTasks.Add(callback());
        }

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

Conclusion

Bien que les gestionnaires d'événements asynchrones ne constituent peut-être pas le meilleur choix de conception, ils peuvent être implémentés de manière attendue à l'aide d'un délégué d'événement personnalisé ou en s'enregistrant et en appelant explicitement un rappel.

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!