Cycle de vie de l’application

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

Le diagramme suivant présente une vue d’ensemble du cycle de vie de l’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 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 n’étant pas en cours d’exécution. Une fois l’application démarrée, les Created événements sont Activated 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 Deactivated événements sont Stopped déclenchés et l’application est arrêtée. Si l’utilisateur retourne à 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 son exécution. Dans ce cas, l’application est désactivée , puis arrêtée, l’événement Destroying est déclenché et l’application n’est pas en cours d’exécution. De même, un appareil peut mettre fin à 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 n’est pas en cours d’exécution.

En outre, .NET MAUI permet aux applications d’être averties lorsque des événements de cycle de vie de la plateforme sont déclenchés. Pour plus d’informations, consultez les événements de cycle de vie de la plateforme.

Événements de cycle de vie multiplateforme

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

Événement	Description	Action à effectuer
Created	Cet événement est déclenché une fois la fenêtre native créée. À ce stade, la fenêtre multiplateforme aura 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 a été activée et est, ou deviendra, la fenêtre prioritaire.
Deactivated	Cet événement est déclenché lorsque la fenêtre n’est plus la fenêtre prioritaire. Toutefois, la fenêtre peut toujours être visible.
Stopped	Cet événement est déclenché lorsque la fenêtre n’est plus visible. Il n’existe aucune garantie qu’une application reprend à partir de cet état, car elle peut être arrêtée par le système d’exploitation.	Déconnectez-vous des processus longs ou annulez les demandes en attente susceptibles de consommer des ressources d’appareil.
Resumed	Cet événement est déclenché lorsqu’une application reprend après l’arrêt. Cet événement ne sera 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 sur 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 par rapport à 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

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

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

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

Pour vous abonner aux événements de Window cycle de vie, remplacez la CreateWindow méthode de votre App classe pour créer une Window instance 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 remplacements de cycle de vie, créez une classe qui dérive de la Window classe

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

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

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

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

Avertissement

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

Événements de cycle de vie de la plateforme

.NET MAUI définit les délégués appelés en réponse aux événements de cycle de vie de la plateforme 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 averties lorsque des événements de cycle de vie de plateforme courants sont déclenchés.

Important

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

Android

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

Déléguer	Arguments	Description	Commentaires
OnActivityResult	Android.App.Activity, , intAndroid.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’objets d’activité, de service ou de récepteur (à l’exception des fournisseurs de contenu).
OnApplicationCreating	Android.App.Application	Appelé lorsque l’application démarre, avant qu’une activité, un service ou des objets récepteurs (à l’exclusion des fournisseurs de contenu) aient été créés.
OnApplicationLowMemory	Android.App.Application	Appelé lorsque le système est en cours d’exécution faible en mémoire 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é qu’il est judicieux qu’un processus supprime la mémoire inutile de son processus.
OnBackPressed	Android.App.Activity	Appelé lorsque l’activité a détecté une pression de 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é lorsque 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 super classe.
OnNewIntent	Android.App.Activity, Android.Content.Intent?	Appelé lorsque l’activité est relancée en haut de la pile d’activités au lieu d’une nouvelle instance de l’activité démarrée.
OnPause	Android.App.Activity	Appelé lorsqu’une activité passe en arrière-plan, mais n’a pas encore été tuée.	Appelez toujours l’implémentation de la super classe.
OnPostCreate	Android.App.Activity, Android.OS.Bundle?	Appelé lorsque le démarrage de l’activité est terminé, après OnStart et OnRestoreInstanceState a été appelé.	Appelez toujours l’implémentation de la super classe. Il s’agit d’un événement système uniquement qui ne doit généralement pas être utilisé par les applications.
OnPostResume	Android.App.Activity	Appelé lorsque la reprise de l’activité est terminée, après OnResume avoir été appelée.	Appelez toujours l’implémentation de la super classe. Il s’agit d’un événement système uniquement qui ne doit généralement pas être utilisé par les applications.
OnRequestPermissionsResult	Android.App.Activity, , intstring[], ,Android.Content.PM.Permission[]	Appelé comme rappel pour le résultat de la demande d’autorisations.
OnRestart	Android.App.Activity	Appelé après OnStop le moment où l’activité actuelle est réaffichée à l’utilisateur (l’utilisateur y a accédé).	Appelez toujours l’implémentation de la super classe.
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, OnRestartou , pour OnPauseindiquer 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é en cours de mort afin que l’état puisse être restauré ou OnCreateOnRestoreInstanceState.
OnStart	Android.App.Activity	Appelé après OnCreate ou OnRestart lorsque l’activité a été arrêtée, mais est désormais affichée à l’utilisateur.	Appelez toujours l’implémentation de la super classe.
OnStop	Android.App.Activity	Appelé lorsque l’activité n’est plus visible par l’utilisateur.	Appelez toujours l’implémentation de la super classe.

Important

Chaque délégué a une méthode d’extension identiquement nommée, 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 Android appelé, appelez la ConfigureLifecycleEvents méthode sur l’objet dans la MauiAppBuilderCreateMauiapp méthode de votre MauiProgram classe. Ensuite, sur l’objet ILifecycleBuilder , appelez la AddAndroid méthode et spécifiez les Action gestionnaires qui inscrivent 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 répertorie les délégués MAUI .NET qui sont appelés en réponse aux événements de cycle de vie iOS déclenchés :

Déléguer	Arguments	Description
ApplicationSignificantTimeChange	UIKit.UIApplication	Appelé lorsqu’un changement de temps significatif se produit, tel que minuit, heure modifiée par l’opérateur ou le début ou l’arrêt des économies d’été.
ContinueUserActivity	UIKit.UIApplication, , Foundation.NSUserActivityUIKit.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 à l’aide du transfert.
DidEnterBackground	UIKit.UIApplication	Appelé lorsque l’application a entré l’arrière-plan.
FinishedLaunching	UIKit.UIApplication, Foundation.NSDictionary	Appelé lorsque l’application a été 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 l’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.UIApplicationShortcutItemUIKit.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 d’extraction si elle a des données à télécharger.
SceneContinueUserActivity	UIKit.UIScene, Foundation.NSUserActivity	Appelé pour gérer l’activité liée au transfert spécifié.
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, , stringFoundation.NSError	Appelé pour informer l’utilisateur que l’activité n’a pas pu être terminé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 de démissionner de 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.UISceneSessionUIKit.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 au transfert.
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 retourne à partir 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 arrêtée en raison de contraintes de mémoire ou directement par l’utilisateur.
WindowSceneDidUpdateCoordinateSpace	UIKit.UIWindowScene, , UIKit.IUICoordinateSpaceUIKit.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 du PerformFetchdélégué, a une méthode d’extension identiquement nommée 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 ConfigureLifecycleEvents méthode sur l’objet dans la MauiAppBuilderCreateMauiapp méthode de votre MauiProgram classe. Ensuite, sur l’objet ILifecycleBuilder , appelez la AddiOS méthode et spécifiez les Action gestionnaires qui inscrivent 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 de l’application iOS, consultez Gestion du cycle de vie de votre application sur developer.apple.com.

Windows

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

Déléguer	Arguments	Description
OnActivated	Microsoft.UI.Xaml.Window, Microsoft.UI.Xaml.WindowActivatedEventArgs	Appelé lorsque l’événement de plateforme Activated est déclenché, si l’application ne reprend pas.
OnClosed	Microsoft.UI.Xaml.Window, Microsoft.UI.Xaml.WindowEventArgs	Appelé lorsque l’événement de plateforme Closed est déclenché.
OnLaunched	Microsoft.UI.Xaml.Window, Microsoft.UI.Xaml.LaunchActivatedEventArgs	Appelé par le remplacement de Application.OnLaunched .NET MAUI une fois la fenêtre native créée et activée.
OnLaunching	Microsoft.UI.Xaml.Window, Microsoft.UI.Xaml.LaunchActivatedEventArgs	Appelé par la substitution de Application.OnLaunched .NET MAUI avant la création et l’activation de la fenêtre native.
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 de plateforme Activated est déclenché, si l’application reprend.
OnVisibilityChanged	Microsoft.UI.Xaml.Window, Microsoft.UI.Xaml.WindowVisibilityChangedEventArgs	Appelé lorsque l’événement de plateforme VisibilityChanged est déclenché.
OnWindowCreated	Microsoft.UI.Xaml.Window	Appelé lorsque la fenêtre native est créée pour la multiplateforme Window.

.NET MAUI expose des messages Windows natifs spécifiques en tant qu’événement de cycle de vie avec le OnPlatformMessage délégué. L’objet WindowsPlatformMessageEventArgs qui accompagne ce délégué inclut une MessageId propriété, de type uint. La valeur de cette propriété peut être examinée pour déterminer quel message a été transmis à votre fenêtre d’application. Pour plus d’informations sur les messages Windows, consultez Messages Windows (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 identiquement nommée, 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 ConfigureLifecycleEvents méthode sur l’objet MauiAppBuilder dans la CreateMauiApp méthode de votre MauiProgram classe. Ensuite, sur l’objet ILifecycleBuilder , appelez la AddWindows méthode et spécifiez les Action gestionnaires qui inscrivent 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 de Window l’application à partir d’événements de cycle de vie de la plateforme, avec la GetWindow méthode d’extension :

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

Bien que .NET MAUI définit les délégués appelés en réponse aux événements de cycle de vie de la plateforme déclenchés, il expose uniquement un ensemble commun d’événements de cycle de vie de la plateforme. Toutefois, il inclut également un mécanisme, généralement destiné aux auteurs de bibliothèques, qui permet aux applications d’être averties 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 de l’événement de cycle de vie de la plateforme, récupérez l’instance ILifecycleEventService et appelez sa InvokeEvents méthode, 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 la plateforme doivent modifier la CreateMauiApp méthode de leur MauiProgram classe pour appeler la ConfigureLifecycleEvents méthode sur l’objet MauiAppBuilder . Ensuite, sur l’objet ILifecycleBuilder , appelez la AddEvent méthode et spécifiez le nom de l’événement de plateforme et celui Action qui sera appelé lorsque l’événement de plateforme est déclenché.

Exemple

L’événement WinUI 3 Window.SizeChanged se produit lorsque la fenêtre d’application native a d’abord rendu ou a changé 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 la Window.SizeChanged plateforme :

  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 de l’événement de cycle de vie de la plateforme, récupérez l’instance ILifecycleEventService et appelez sa InvokeEvents méthode, 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 MauiWinUIApplication type sur Windows peut être utilisé pour accéder à l’instance d’application native via sa Current propriété. Le MauiApplication type sur Android peut être utilisé pour accéder à l’instance d’application native. De même, le MauiUIApplicationDelegate type sur iOS peut être utilisé pour accéder à l’instance d’application native.

  Avertissement

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

• Dans la CreateMauiApp méthode de votre MauiProgram classe, appelez la ConfigureLifecycleEvents méthode sur l’objet MauiAppBuilder . Ensuite, sur l’objet ILifecycleBuilder , appelez la AddEvent méthode et spécifiez le nom de l’événement de plateforme et celui Action qui sera appelé 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 lorsqu’un utilisateur modifie la taille de la fenêtre d’application sur Windows, l’action spécifiée dans la AddEvent méthode est exécutée.

Remarque

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