Cycle de vie de l’application

Article
10/31/2024

Les applications .NET Multi-platform App UI (.NET MAUI) ont généralement quatre états d’exécution : non exécuté, en cours d’exécution, désactivé et arrêté. .NET MAUI déclenche des événements de cycle de vie multiplateforme sur la classe Window lorsqu’une application passe de l’état non exécuté à l’état en cours d’exécution, de l’état en cours d’exécution à l’état désactivé, de l’état désactivé à l’état arrêté, de l’état arrêté à l’état en cours d’exécution et de l’état arrêté à l’état non exécuté.

Le diagramme suivant présente une vue d’ensemble du cycle de vie d’une application .NET MAUI :

Cycle de vie d’une application .NET MAUI

Dans le diagramme, l’ovale gris indique que l’application n’est pas chargée en mémoire. Les ovales bleu clair indiquent que l’application est en mémoire. Le texte sur les arcs indique les événements déclenchés par .NET MAUI, qui fournissent des notifications à l’application en cours d’exécution.

L’état d’exécution d’une application dépend de l’historique de l’application. Par exemple, lorsqu’une application est installée pour la première fois ou qu’un appareil est démarré, l’application peut être considérée comme non exécutée. Une fois que l’application est démarrée, les événements Created et Activated sont déclenchés et l’application est en cours d’exécution. Si une autre fenêtre d’application obtient le focus, l’événement Deactivated est déclenché et l’application est désactivée. Si l’utilisateur bascule vers une autre application ou retourne à l’écran d’accueil de l’appareil afin que la fenêtre de l’application ne soit plus visible, les événements Deactivated et Stopped sont déclenchés et l’application est arrêtée. Si l’utilisateur revient à l’application, l’événement Resuming est déclenché et l’application est en cours d’exécution. Une application peut également être arrêtée par un utilisateur pendant qu’elle est exécutée. Dans ce cas, l’application est désactivée puis arrêtée, l’événement Destroying est déclenché et l’application est non exécutée. De même, un appareil peut terminer une application lorsqu’elle est arrêtée, en raison de restrictions de ressources, et l’événement Destroying est déclenché et l’application est non exécutée.

De plus, .NET MAUI permet aux applications d’être notifiées lorsque des événements de cycle de vie de plateforme sont déclenchés. Pour plus d’informations, consultez Événements de cycle de vie de plateforme.

Événements de cycle de vie multiplateforme

La classe Window définit les événements de cycle de vie multiplateforme suivants :

Event	Description	Action à effectuer
`Created`	Cet événement est déclenché une fois que la fenêtre native est créée. À ce stade, la fenêtre multiplateforme a un gestionnaire de fenêtre native, mais la fenêtre peut ne pas encore être visible.
`Activated`	Cet événement est déclenché lorsque la fenêtre est activée et est, ou deviendra, la fenêtre avec le focus.
`Deactivated`	Cet événement est déclenché lorsque la fenêtre n’est plus la fenêtre avec le focus. Toutefois, la fenêtre peut rester visible.
`Stopped`	Cet événement est déclenché lorsque la fenêtre n’est plus visible. La reprise de l’application à partir de cet état n’est pas garantie, car l’application peut être terminée par le système d’exploitation.	Déconnectez-vous des processus longs ou annulez les demandes en attente susceptibles de consommer les ressources de l’appareil.
`Resumed`	Cet événement est déclenché lorsqu’une application reprend après avoir été arrêtée. Cet événement n’est pas déclenché la première fois que votre application démarre et ne peut être déclenché que si l’événement `Stopped` a déjà été déclenché.	Abonnez-vous à tous les événements requis et actualisez tout contenu figurant dans la page visible.
`Destroying`	Cet événement est déclenché lorsque la fenêtre native est détruite et libérée. La même fenêtre multiplateforme peut être utilisée sur une nouvelle fenêtre native lorsque l’application est rouverte.	Supprimez les abonnements aux événements que vous avez attachés à la fenêtre native.

Ces événements multiplateformes sont mappés à différents événements de plateforme, et le tableau suivant montre ce mappage :

Événement	Android	iOS	Windows
`Created`	`OnPostCreate`	`FinishedLaunching`	`Created`
`Activated`	`OnResume`	`OnActivated`	`Activated` (`CodeActivated` et `PointerActivated`)
`Deactivated`	`OnPause`	`OnResignActivation`	`Activated` (`Deactivated`)
`Stopped`	`OnStop`	`DidEnterBackground`	`VisibilityChanged`
`Resumed`	`OnRestart`	`WillEnterForeground`	`Resumed`
`Destroying`	`OnDestroy`	`WillTerminate`	`Closed`

De plus, la classe Window définit également un événement Backgrounding déclenché sur iOS et Mac Catalyst lorsque la fenêtre est fermée ou entre dans un état d’arrière-plan. Un objet BackgroundingEventArgs accompagne cet événement et tout état string doit être conservé dans la propriété State de l’objet BackgroundingEventArgs, que le système d’exploitation conserve jusqu’à ce que ce soit le moment de reprendre la fenêtre. Lorsque la fenêtre reprend, l’état est fourni par l’argument IActivationState à la substitution de CreateWindow.

En plus de ces événements, la classe Window a également les méthodes de cycle de vie substituables suivantes :

OnCreated, qui est appelée lorsque l’événement Created est déclenché.
OnActivated, qui est appelée lorsque l’événement Activated est déclenché.
OnDeactivated, qui est appelée lorsque l’événement Deactivated est déclenché.
OnStopped, qui est appelée lorsque l’événement Stopped est déclenché.
OnResumed, qui est appelée lorsque l’événement Resumed est déclenché.
OnDestroying, qui est appelée lorsque l’événement Destroying est déclenché.
OnBackgrounding, qui est appelée lorsque l’événement Backgrounding est déclenché.

Pour vous abonner aux événements de cycle de vie Window, substituez la méthode CreateWindow dans votre classe App pour créer une instance Window sur laquelle vous pouvez vous abonner aux événements :

namespace MyMauiApp
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();

            MainPage = new MainPage();
        }

        protected override Window CreateWindow(IActivationState? activationState)
        {
            Window window = new Window(new AppShell());

            window.Created += (s, e) =>
            {
                // Custom logic
            };

            return window;
        }
    }
}

namespace MyMauiApp
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();
        }

        protected override Window CreateWindow(IActivationState activationState)
        {
            Window window = base.CreateWindow(activationState);

            window.Created += (s, e) =>
            {
                // Custom logic
            };

            return window;
        }
    }
}

Sinon, pour consommer les substitutions de cycle de vie, créez une classe qui dérive de la classe Window

namespace MyMauiApp
{
    public class MyWindow : Window
    {
        public MyWindow() : base()
        {
        }

        public MyWindow(Page page) : base(page)
        {
        }

        protected override void OnCreated()
        {
            // Register services
        }
    }
}

La classe dérivée de Windowpeut ensuite être consommée en substituant la méthode CreateWindow dans votre classe App pour retourner une instance MyWindow.

Avertissement

Une InvalidOperationException est levée si la propriété App.MainPage est définie et que la méthode CreateWindow crée un objet Window à l’aide de la substitution qui accepte un argument Page.

Événements de cycle de vie de plateforme

.NET MAUI définit des délégués qui sont appelés en réponse aux événements de cycle de vie de plateforme qui sont déclenchés. Les gestionnaires peuvent être spécifiés pour ces délégués à l’aide de méthodes nommées ou de fonctions anonymes, qui sont exécutées lorsque le délégué est appelé. Ce mécanisme permet aux applications d’être notifiées lorsque des événements de cycle de vie de plateforme courants sont déclenchés.

Important

La méthode ConfigureLifecycleEvents se trouve dans l’espace de noms Microsoft.Maui.LifecycleEvents.

Android

Le tableau suivant dresse la liste des délégués .NET MAUI qui sont appelés en réponse aux événements de cycle de vie Android qui sont déclenchés :

Déléguer	Arguments	Description	Commentaires
`OnActivityResult`	`Android.App.Activity`, `int`, `Android.App.Result`, `Android.Content.Intent?`	Appelé lorsqu’une activité que vous avez lancée s’arrête.
`OnApplicationConfigurationChanged`	`Android.App.Application`, `Android.Content.Res.Configuration`	Appelé lorsque la configuration de l’appareil change pendant l’exécution de votre composant.
`OnApplicationCreate`	`Android.App.Application`	Appelé lorsque l’application a démarré, avant la création d’une activité, d’un service ou d’objets récepteur (à l’exception des fournisseurs de contenu).
`OnApplicationCreating`	`Android.App.Application`	Appelé lorsque l’application démarre, avant la création d’une activité, d’un service ou d’objets récepteur (à l’exception des fournisseurs de contenu).
`OnApplicationLowMemory`	`Android.App.Application`	Appelé lorsque le système présente une mémoire faible et que les processus en cours d’exécution doivent réduire leur utilisation de la mémoire.
`OnApplicationTrimMemory`	`Android.App.Application`, `Android.Content.TrimMemory`	Appelé lorsque le système d’exploitation a déterminé que c’est le bon moment pour qu’un processus réduise la mémoire dont il n’a pas besoin.
`OnBackPressed`	`Android.App.Activity`	Appelé lorsque l’activité a détecté une pression sur la touche précédent.
`OnConfigurationChanged`	`Android.App.Activity`, `Android.Content.Res.Configuration`	Appelé lorsque la configuration de l’appareil change pendant l’exécution de votre activité.
`OnCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Déclenché quand l’activité est créée.
`OnDestroy`	`Android.App.Activity`	Appelé lorsque l’activité se termine ou parce que le système détruit temporairement l’instance d’activité pour économiser de l’espace.	Appelez toujours l’implémentation de la superclasse.
`OnNewIntent`	`Android.App.Activity`, `Android.Content.Intent?`	Appelé lorsque l’activité est redémarrée alors qu’elle est en haut de la pile d’activités, au lieu de démarrer une nouvelle instance de l’activité.
`OnPause`	`Android.App.Activity`	Appelé lorsqu’une activité passe en arrière-plan, mais qu’elle n’a pas encore été tuée.	Appelez toujours l’implémentation de la superclasse.
`OnPostCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Appelé lorsque le démarrage de l’activité est terminé, une fois que `OnStart` et `OnRestoreInstanceState` ont été appelés.	Appelez toujours l’implémentation de la superclasse. Il s’agit d’un événement réservé au système qui ne doit pas être utilisé par les applications en règle générale.
`OnPostResume`	`Android.App.Activity`	Appelé lorsque la reprise de l’activité est terminée, une fois que `OnResume` a été appelé.	Appelez toujours l’implémentation de la superclasse. Il s’agit d’un événement réservé au système qui ne doit pas être utilisé par les applications en règle générale.
`OnRequestPermissionsResult`	`Android.App.Activity`, `int`, `string[]`, `Android.Content.PM.Permission[]`	Appelé comme rappel pour le résultat de la demande d’autorisations.
`OnRestart`	`Android.App.Activity`	Appelé après `OnStop` lorsque l’activité actuelle est réaffichée à l’utilisateur (l’utilisateur y est revenue).	Appelez toujours l’implémentation de la superclasse.
`OnRestoreInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Appelé après `OnStart` lorsque l’activité est réinitialisée à partir d’un état précédemment enregistré.
`OnResume`	`Android.App.Activity`	Appelé après `OnRestoreInstanceState`, `OnRestart` ou `OnPause` pour indiquer que l’activité est active et est prête à recevoir une entrée.
`OnSaveInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Appelé pour récupérer l’état par instance d’une activité tuée afin que l’état puisse être restauré dans `OnCreate` ou `OnRestoreInstanceState`.
`OnStart`	`Android.App.Activity`	Appelé après `OnCreate` ou `OnRestart` lorsque l’activité a été arrêtée, mais est maintenant affichée à l’utilisateur.	Appelez toujours l’implémentation de la superclasse.
`OnStop`	`Android.App.Activity`	Appelé lorsque l’activité n’est plus visible par l’utilisateur.	Appelez toujours l’implémentation de la superclasse.

Important

Chaque délégué a une méthode d’extension du même nom correspondante, qui peut être appelée pour inscrire un gestionnaire pour le délégué.

Pour répondre à un(e) délégué(e) de cycle de vie Android appelé(e), appelez la méthode ConfigureLifecycleEvents sur l’objet MauiAppBuilder dans la méthode CreateMauiapp de votre classe MauiProgram. Ensuite, sur l’objet ILifecycleBuilder, appelez la méthode AddAndroid et spécifiez l’Action qui inscrit les gestionnaires pour les délégués requis :

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if ANDROID
                    events.AddAndroid(android => android
                        .OnActivityResult((activity, requestCode, resultCode, data) => LogEvent(nameof(AndroidLifecycle.OnActivityResult), requestCode.ToString()))
                        .OnStart((activity) => LogEvent(nameof(AndroidLifecycle.OnStart)))
                        .OnCreate((activity, bundle) => LogEvent(nameof(AndroidLifecycle.OnCreate)))
                        .OnBackPressed((activity) => LogEvent(nameof(AndroidLifecycle.OnBackPressed)) && false)
                        .OnStop((activity) => LogEvent(nameof(AndroidLifecycle.OnStop))));
#endif
                    static bool LogEvent(string eventName, string type = null)
                    {
                        System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                        return true;
                    }
                });

            return builder.Build();
        }
    }
}

Pour plus d’informations sur le cycle de vie des applications Android, consultez Comprendre le cycle de vie des activités sur developer.android.com.

iOS/Mac Catalyst

Le tableau suivant liste les délégués .NET MAUI qui sont appelés en réponse aux événements de cycle de vie iOS et Mac Catalyst qui sont déclenchés :

Déléguer	Arguments	Description
`ApplicationSignificantTimeChange`	`UIKit.UIApplication`	Appelé lorsqu’un changement d’heure significatif se produit, tel que minuit, l’heure changée par l’opérateur ou le début ou la fin de l’heure d’été.
`ContinueUserActivity`	`UIKit.UIApplication`, `Foundation.NSUserActivity`, `UIKit.UIApplicationRestorationHandler`	Appelé lorsque l’application reçoit des données associées à une activité utilisateur, telles que le transfert d’une activité à partir d’un autre appareil avec Handoff.
`DidEnterBackground`	`UIKit.UIApplication`	Appelé lorsque l’application entre en arrière-plan.
`FinishedLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Appelé lorsque l’application est lancée.
`OnActivated`	`UIKit.UIApplication`	Appelé lorsque l’application est lancée et chaque fois que l’application revient au premier plan.
`OnResignActivation`	`UIKit.UIApplication`	Appelé lorsque l’application est sur le point d’entrer en arrière-plan, d’être suspendue ou lorsque l’utilisateur reçoit une interruption telle qu’un appel téléphonique ou du texte.
`OpenUrl`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Appelé lorsque l’application doit ouvrir une URL spécifiée.
`PerformActionForShortcutItem`	`UIKit.UIApplication`, `UIKit.UIApplicationShortcutItem`, `UIKit.UIOperationHandler`	Appelé lorsqu’une action rapide de l’écran d’accueil est lancée.
`PerformFetch`	`UIKit.UIApplication`, `Action<UIBackgroundFetchResult>`	Appelé pour indiquer à l’application qu’elle peut commencer une opération de récupération si elle a des données à télécharger.
`SceneContinueUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Appelé pour gérer l’activité liée à Handoff spécifiée.
`SceneDidDisconnect`	`UIKit.UIScene`	Appelé lorsqu’une scène est supprimée de l’application.
`SceneDidEnterBackground`	`UIKit.UIScene`	Appelé lorsqu’une scène s’exécute en arrière-plan et n’est pas à l’écran.
`SceneDidFailToContinueUserActivity`	`UIKit.UIScene`, `string`, `Foundation.NSError`	Appelé pour informer l’utilisateur que l’activité n’a pas pu être effectuée.
`SceneDidUpdateUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Appelé lorsque l’activité spécifiée est mise à jour.
`SceneOnActivated`	`UIKit.UIScene`	Appelé lorsque la scène devient active et capable de répondre aux événements utilisateur.
`SceneOnResignActivation`	`UIKit.UIScene`	Appelé lorsque la scène est sur le point d’abandonner l’état actif et d’arrêter de répondre aux événements utilisateur.
`SceneOpenUrl`	`UIKit.UIScene`, `Foundation.NSSet<UIKit.UIOpenUrlContext>`	Appelé lorsqu’une scène demande d’ouvrir une ou plusieurs URL.
`SceneRestoreInteractionState`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Appelé pour restaurer l’état de l’activité.
`SceneWillConnect`	`UIKit.UIScene`, `UIKit.UISceneSession`, `UIKit.UISceneConnectionOptions`	Appelé lorsqu’une scène est ajoutée à l’application.
`SceneWillContinueUserActivity`	`UIKit.UIScene`, `string`	Appelé pour préparer la réception des données liées à Handoff.
`SceneWillEnterForeground`	`UIKit.UIScene`	Appelé lorsqu’une scène est sur le point de s’exécuter au premier plan et de devenir visible par l’utilisateur.
`WillEnterForeground`	`UIKit.UIApplication`	Appelé si l’application revient d’un état en arrière-plan.
`WillFinishLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Appelé lorsque le lancement de l’application a commencé, mais que la restauration de l’état n’a pas encore eu lieu.
`WillTerminate`	`UIKit.UIApplication`	Appelé si l’application est terminée en raison de contraintes de mémoire ou directement par l’utilisateur.
`WindowSceneDidUpdateCoordinateSpace`	`UIKit.UIWindowScene`, `UIKit.IUICoordinateSpace`, `UIKit.UIInterfaceOrientation`, `UIKit.UITraitCollection`	Appelé lorsque la taille, l’orientation ou les caractéristiques d’une scène changent.

Important

Chaque délégué, à l’exception de PerformFetch, a une méthode d’extension du même nom correspondante qui peut être appelée pour inscrire un gestionnaire pour le délégué.

Pour répondre à un délégué de cycle de vie iOS et Mac Catalyst appelé, appelez la méthode ConfigureLifecycleEvents sur l’objet MauiAppBuilder dans la méthode CreateMauiapp de votre classe MauiProgram. Ensuite, sur l’objet ILifecycleBuilder, appelez la méthode AddiOS et spécifiez l’Action qui inscrit les gestionnaires pour les délégués requis :

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if IOS || MACCATALYST
                    events.AddiOS(ios => ios
                        .OnActivated((app) => LogEvent(nameof(iOSLifecycle.OnActivated)))
                        .OnResignActivation((app) => LogEvent(nameof(iOSLifecycle.OnResignActivation)))
                        .DidEnterBackground((app) => LogEvent(nameof(iOSLifecycle.DidEnterBackground)))
                        .WillTerminate((app) => LogEvent(nameof(iOSLifecycle.WillTerminate))));
#endif
                    static bool LogEvent(string eventName, string type = null)
                    {
                        System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                        return true;
                    }
                });

            return builder.Build();
        }
    }
}

Pour plus d’informations sur le cycle de vie des applications iOS, consultez Gestion du cycle de vie de votre application sur developer.apple.com.

Windows

Le tableau suivant dresse la liste des délégués .NET MAUI qui sont appelés en réponse aux événements de cycle de vie Windows qui sont déclenchés :

Déléguer	Arguments	Description
`OnActivated`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowActivatedEventArgs`	Appelé lorsque l’événement Activated de la plateforme est déclenché, si l’application ne reprend pas.
`OnClosed`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowEventArgs`	Appelé lorsque l’événement Closed de la plateforme est déclenché.
`OnLaunched`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Appelé par la substitution Application.OnLaunched de .NET MAUI une fois que la fenêtre native a été créée et activée.
`OnLaunching`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Appelé par la substitution Application.OnLaunched de .NET MAUI avant que la fenêtre native ne soit créée et activée.
`OnPlatformMessage`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformMessageEventArgs`	Appelé lorsque .NET MAUI reçoit des messages Windows natifs spécifiques.
`OnPlatformWindowSubclassed`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformWindowSubclassedEventArgs`	Appelé par .NET MAUI lorsque la fenêtre Win32 est sous-classée.
`OnResumed`	`Microsoft.UI.Xaml.Window`	Appelé lorsque l’événement `Activated` de la plateforme est déclenché, si l’application reprend.
`OnVisibilityChanged`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowVisibilityChangedEventArgs`	Appelé lorsque l’événement VisibilityChanged de la plateforme est déclenché.
`OnWindowCreated`	`Microsoft.UI.Xaml.Window`	Appelé lorsque la fenêtre native est créée pour la `Window`multiplateforme.

.NET MAUI expose des messages Windows natifs spécifiques en tant qu’événement de cycle de vie avec le délégué OnPlatformMessage. L’objet WindowsPlatformMessageEventArgs qui accompagne ce délégué inclut une propriété MessageId de type uint. La valeur de cette propriété peut être examinée pour déterminer quel message a été passé à votre fenêtre d’application. Pour plus d’informations sur les messages de fenêtres, consultez Messages de fenêtres (Prise en main de Win32 et C++). Pour obtenir la liste des constantes de message de fenêtre, consultez Notifications de fenêtre.

Important

Chaque délégué a une méthode d’extension du même nom correspondante, qui peut être appelée pour inscrire un gestionnaire pour le délégué.

Pour répondre à un délégué de cycle de vie Windows appelé, appelez la méthode ConfigureLifecycleEvents sur l’objet MauiAppBuilder dans la méthode CreateMauiApp de votre classe MauiProgram. Ensuite, sur l’objet ILifecycleBuilder, appelez la méthode AddWindows et spécifiez l’Action qui inscrit les gestionnaires pour les délégués requis :

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if WINDOWS
                    events.AddWindows(windows => windows
                           .OnActivated((window, args) => LogEvent(nameof(WindowsLifecycle.OnActivated)))
                           .OnClosed((window, args) => LogEvent(nameof(WindowsLifecycle.OnClosed)))
                           .OnLaunched((window, args) => LogEvent(nameof(WindowsLifecycle.OnLaunched)))
                           .OnLaunching((window, args) => LogEvent(nameof(WindowsLifecycle.OnLaunching)))
                           .OnVisibilityChanged((window, args) => LogEvent(nameof(WindowsLifecycle.OnVisibilityChanged)))
                           .OnPlatformMessage((window, args) =>
                           {
                               if (args.MessageId == Convert.ToUInt32("031A", 16))
                               {
                                   // System theme has changed
                               }
                           }));
#endif
                    static bool LogEvent(string eventName, string type = null)
                    {
                        System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                        return true;
                    }
                });

            return builder.Build();
        }
    }
}

Récupérer l’objet Window

Le code de plateforme peut récupérer l’objet Window de l’application à partir des événements de cycle de vie de plateforme, avec la méthode d’extension GetWindow :

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if WINDOWS
                    events.AddWindows(windows => windows
                            .OnClosed((window, args) =>
                            {
                                IWindow appWindow = window.GetWindow();
                            }));
#endif
                });

            return builder.Build();
        }
    }
}

Événements de cycle de vie personnalisés

Même si .NET MAUI définit les délégués appelés en réponse aux événements de cycle de vie de plateforme déclenchés, il expose uniquement un ensemble commun d’événements de cycle de vie de plateforme. Toutefois, il inclut également un mécanisme, généralement destiné aux auteurs de bibliothèques, qui permet aux applications d’être notifiées lorsque des événements de cycle de vie de plateforme supplémentaires sont déclenchés. Pour ce faire, procédez comme suit :

Inscrivez un gestionnaire d’événements pour un événement de cycle de vie de plateforme qui n’est pas exposé par .NET MAUI.
Dans le gestionnaire d’événements pour l’événement de cycle de vie de plateforme, récupérez l’instance ILifecycleEventService et appelez sa méthode InvokeEvents, en spécifiant le nom de l’événement de plateforme comme argument.

Ensuite, les applications qui souhaitent recevoir une notification de l’événement de cycle de vie de plateforme doivent modifier la méthode CreateMauiApp de leur classe MauiProgram pour appeler la méthode ConfigureLifecycleEvents sur l’objet MauiAppBuilder. Puis, sur l’objet ILifecycleBuilder, appelez la méthode AddEvent et spécifiez le nom de l’événement de plateforme et l’Action à appeler lorsque l’événement de plateforme est déclenché.

Exemple

L’événement Window.SizeChanged WinUI 3 se produit lorsque la fenêtre d’application native est rendue pour la première fois ou lorsqu’elle change sa taille de rendu. .NET MAUI n’expose pas cet événement de plateforme en tant qu’événement de cycle de vie. Toutefois, les applications peuvent recevoir une notification lorsque cet événement de plateforme est déclenché à l’aide de l’approche suivante :

Inscrivez un gestionnaire d’événements pour l’événement de cycle de vie de plateforme Window.SizeChanged :

using Microsoft.Maui.LifecycleEvents;
...

public static MauiApp CreateMauiApp()
{
      var builder = MauiApp.CreateBuilder();
      builder
            .UseMauiApp<App>()
            .ConfigureLifecycleEvents(events =>
            {
#if WINDOWS
                  events.AddWindows(windows => windows
                         .OnWindowCreated(window =>
                         {
                                window.SizeChanged += OnSizeChanged;
                         }));
#endif
            });

      return builder.Build();
}

Dans le gestionnaire d’événements pour l’événement de cycle de vie de plateforme, récupérez l’instance ILifecycleEventService et appelez sa méthode InvokeEvents, en spécifiant le nom de l’événement de plateforme comme argument :
```
using Microsoft.Maui.LifecycleEvents;
...

#if WINDOWS
        static void OnSizeChanged(object sender, Microsoft.UI.Xaml.WindowSizeChangedEventArgs args)
        {
            ILifecycleEventService service = MauiWinUIApplication.Current.Services.GetRequiredService<ILifecycleEventService>();
            service.InvokeEvents(nameof(Microsoft.UI.Xaml.Window.SizeChanged));
        }
#endif
```
Le type MauiWinUIApplication sur Windows peut être utilisé pour accéder à l’instance d’application native via sa propriété Current. Le type MauiApplication sur Android peut être utilisé pour accéder à l’instance d’application native. De même, le type MauiUIApplicationDelegate sur iOS peut être utilisé pour accéder à l’instance d’application native.

Avertissement

L’appel d’un événement non inscrit, avec la méthode InvokeEvents, ne lève pas d’exception.

Dans la méthode CreateMauiApp de votre classe MauiProgram, appelez la méthode ConfigureLifecycleEvents sur l’objet MauiAppBuilder. Puis, sur l’objet ILifecycleBuilder, appelez la méthode AddEvent et spécifiez le nom de l’événement de plateforme et l’Action à appeler lorsque l’événement de plateforme est déclenché :

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureLifecycleEvents(events =>
                {
#if WINDOWS
                    events.AddWindows(windows => windows
                           .OnWindowCreated(window =>
                           {
                                  window.SizeChanged += OnSizeChanged;
                           }));

                    events.AddEvent(nameof(Microsoft.UI.Xaml.Window.SizeChanged), () => LogEvent("Window SizeChanged"));
#endif
                    static bool LogEvent(string eventName, string type = null)
                    {
                        System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                        return true;
                    }
                });

            return builder.Build();
        }
    }
}

L’effet global est que quand un utilisateur change la taille de la fenêtre d’application sur Windows, l’action spécifiée dans la méthode AddEvent est exécutée.

Remarque

La méthode AddEvent a également une surcharge qui permet à un délégué d’être spécifié.

Partager via

Cycle de vie de l’application

Événements de cycle de vie multiplateforme

Événements de cycle de vie de plateforme

Android

iOS/Mac Catalyst

Windows

Récupérer l’objet Window

Événements de cycle de vie personnalisés

Exemple

Ressources supplémentaires