Share via

Cycle de vie de l’application

  • Article

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 = 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

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 iOS 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 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
                    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 Windowmultiplateforme.

.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é.