Ciclo di vita dell'app

Articolo
05/14/2024

Le app .NET multipiattaforma dell'interfaccia utente dell'app (.NET MAUI) hanno in genere quattro stati di esecuzione: non in esecuzione, in esecuzione, disattivati e arrestati. .NET MAUI genera eventi del ciclo di vita multipiattaforma nella Window classe quando un'app passa dallo stato non in esecuzione allo stato in esecuzione, lo stato di esecuzione allo stato disattivato, lo stato disattivato allo stato arrestato, lo stato arrestato allo stato in esecuzione e lo stato arrestato fino allo stato non in esecuzione.

Il diagramma seguente mostra una panoramica del ciclo di vita dell'app .NET MAUI:

Ciclo di vita dell'app .NET MAUI

Nel diagramma l'ovale grigio indica che l'app non viene caricata in memoria. Gli ovali blu chiaro indicano che l'app è in memoria. Il testo sugli archi indica gli eventi generati da .NET MAUI, che forniscono notifiche all'app in esecuzione.

Lo stato di esecuzione di un'app dipende dalla cronologia dell'app. Ad esempio, quando un'app viene installata per la prima volta o quando viene avviato un dispositivo, l'app può essere considerata non in esecuzione. Quando l'app viene avviata, Created vengono generati gli eventi e Activated e l'app è in esecuzione. Se una finestra dell'app diversa ottiene lo stato attivo, viene generato l'evento Deactivated e l'app viene disattivata. Se l'utente passa a un'app diversa o torna alla schermata Iniziale del dispositivo, in modo che la finestra dell'app non sia più visibile, gli Deactivated eventi e Stopped vengono generati e l'app viene arrestata. Se l'utente torna all'app, viene generato l'evento Resuming e l'app è in esecuzione. In alternativa, un'app potrebbe essere terminata da un utente durante l'esecuzione. In questo caso l'app viene disattivata e quindi arrestata, viene generato l'evento Destroying e l'app non è in esecuzione. Analogamente, un dispositivo potrebbe terminare un'app mentre è arrestata, a causa di restrizioni delle risorse e l'evento Destroying viene generato e l'app non è in esecuzione.

.NET MAUI consente inoltre alle app di ricevere notifiche quando vengono generati eventi del ciclo di vita della piattaforma. Per altre informazioni, vedere Eventi del ciclo di vita della piattaforma.

Eventi del ciclo di vita multipiattaforma

La Window classe definisce gli eventi del ciclo di vita multipiattaforma seguenti:

Evento	Descrizione	Azione da eseguire
`Created`	Questo evento viene generato dopo la creazione della finestra nativa. A questo punto la finestra multipiattaforma avrà un gestore della finestra nativa, ma la finestra potrebbe non essere ancora visibile.
`Activated`	Questo evento viene generato quando la finestra è stata attivata e diventa, o diventerà, la finestra con lo stato attivo.
`Deactivated`	Questo evento viene generato quando la finestra non è più attiva. Tuttavia, la finestra potrebbe essere ancora visibile.
`Stopped`	Questo evento viene generato quando la finestra non è più visibile. Non esiste alcuna garanzia che un'app riprenderà da questo stato, perché potrebbe essere terminata dal sistema operativo.	Disconnettersi da qualsiasi processo a esecuzione prolungata o annullare eventuali richieste in sospeso che potrebbero utilizzare le risorse del dispositivo.
`Resumed`	Questo evento viene generato quando un'app riprende dopo l'arresto. Questo evento non verrà generato la prima volta che viene avviata l'app e può essere generato solo se l'evento `Stopped` è stato generato in precedenza.	Sottoscrivere gli eventi necessari e aggiornare tutti i contenuti presenti nella pagina visibile.
`Destroying`	Questo evento viene generato quando la finestra nativa viene eliminata e deallocata. La stessa finestra multipiattaforma potrebbe essere usata in una nuova finestra nativa quando l'app viene riaperta.	Rimuovere tutte le sottoscrizioni di eventi associate alla finestra nativa.

Questi eventi multipiattaforma sono mappati a diversi eventi della piattaforma e la tabella seguente illustra questo mapping:

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

Inoltre, la Window classe definisce anche un Backgrounding evento generato in iOS e Mac Catalyst quando la finestra viene chiusa o entra in uno stato di sfondo. Un BackgroundingEventArgs oggetto accompagna questo evento e qualsiasi string stato deve essere salvato in modo permanente nella State proprietà dell'oggetto BackgroundingEventArgs , che il sistema operativo manterrà fino a quando non sarà il momento di riprendere la finestra. Quando la finestra viene ripresa, lo stato viene fornito dall'argomento IActivationState all'override CreateWindow .

Oltre a questi eventi, la Window classe include anche i metodi del ciclo di vita sostituibili seguenti:

OnCreated, che viene richiamato quando viene generato l'evento Created .
OnActivated, che viene richiamato quando viene generato l'evento Activated .
OnDeactivated, che viene richiamato quando viene generato l'evento Deactivated .
OnStopped, che viene richiamato quando viene generato l'evento Stopped .
OnResumed, che viene richiamato quando viene generato l'evento Resumed .
OnDestroying, che viene richiamato quando viene generato l'evento Destroying .
OnBackgrounding, che viene richiamato quando viene generato l'evento Backgrounding .

Per sottoscrivere gli eventi del ciclo di vita, eseguire l'override Window del CreateWindow metodo nella App classe per creare un'istanza Window in cui è possibile sottoscrivere gli eventi:

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;
        }
    }
}

In alternativa, per utilizzare gli override del ciclo di vita, creare una classe che deriva dalla 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 derivata da può quindi essere utilizzata eseguendo l'override del CreateWindow metodo nella App classe per restituire un'istanza MyWindow .

Avviso

Verrà generata un'eccezione InvalidOperationException se la App.MainPage proprietà è impostata e il CreateWindow metodo crea un Window oggetto utilizzando l'override che accetta un Page argomento.

Eventi del ciclo di vita della piattaforma

.NET MAUI definisce i delegati richiamati in risposta agli eventi del ciclo di vita della piattaforma generati. I gestori possono essere specificati per questi delegati, usando metodi denominati o funzioni anonime, che vengono eseguiti quando viene richiamato il delegato. Questo meccanismo consente alle app di ricevere notifiche quando vengono generati eventi comuni del ciclo di vita della piattaforma.

Importante

Il ConfigureLifecycleEvents metodo si trova nello spazio dei Microsoft.Maui.LifecycleEvents nomi .

Android

La tabella seguente elenca i delegati MAUI .NET richiamati in risposta agli eventi del ciclo di vita di Android generati:

Delega	Argomenti	Descrizione	Commenti
`OnActivityResult`	`Android.App.Activity`, `int`, `Android.App.ResultAndroid.Content.Intent?`	Richiamato quando un'attività avviata viene chiusa.
`OnApplicationConfigurationChanged`	`Android.App.Application`, `Android.Content.Res.Configuration`	Richiamato quando la configurazione del dispositivo cambia durante l'esecuzione del componente.
`OnApplicationCreate`	`Android.App.Application`	Richiamato all'avvio dell'app, prima che siano stati creati oggetti attività, servizio o ricevitore (esclusi i provider di contenuto).
`OnApplicationCreating`	`Android.App.Application`	Richiamato all'avvio dell'app, prima che siano stati creati oggetti attività, servizio o ricevitore (esclusi i provider di contenuti).
`OnApplicationLowMemory`	`Android.App.Application`	Richiamato quando il sistema è in esecuzione insufficiente nella memoria e l'esecuzione attiva dei processi deve ridurre l'utilizzo della memoria.
`OnApplicationTrimMemory`	`Android.App.Application`, `Android.Content.TrimMemory`	Richiamato quando il sistema operativo ha determinato che è un buon momento per un processo per ridurre la memoria non richiesta dal processo.
`OnBackPressed`	`Android.App.Activity`	Richiamato quando l'attività ha rilevato una pressione del tasto Indietro.
`OnConfigurationChanged`	`Android.App.Activity`, `Android.Content.Res.Configuration`	Richiamato quando la configurazione del dispositivo cambia durante l'esecuzione dell'attività.
`OnCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Generato quando viene creata l'attività.
`OnDestroy`	`Android.App.Activity`	Richiamato al termine dell'attività o perché il sistema sta eliminando temporaneamente l'istanza dell'attività per risparmiare spazio.	Chiamare sempre l'implementazione della classe super.
`OnNewIntent`	`Android.App.Activity`, `Android.Content.Intent?`	Richiamato quando l'attività viene riavviata all'inizio dello stack di attività anziché una nuova istanza dell'attività avviata.
`OnPause`	`Android.App.Activity`	Richiamato quando un'attività entra in background, ma non è ancora stata uccisa.	Chiamare sempre l'implementazione della classe super.
`OnPostCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Richiamato al termine dell'avvio dell'attività, dopo `OnStart` e `OnRestoreInstanceState` dopo che è stato chiamato .	Chiamare sempre l'implementazione della classe super. Si tratta di un evento di sola sistema che in genere non deve essere usato dalle app.
`OnPostResume`	`Android.App.Activity`	Richiamato al termine della ripresa dell'attività, dopo `OnResume` la chiamata.	Chiamare sempre l'implementazione della classe super. Si tratta di un evento di sola sistema che in genere non deve essere usato dalle app.
`OnRequestPermissionsResult`	`Android.App.Activity`, `int`, `string[]Android.Content.PM.Permission[]`	Richiamato come callback per il risultato dalla richiesta di autorizzazioni.
`OnRestart`	`Android.App.Activity`	Richiamato dopo `OnStop` la riesecuzione dell'attività corrente all'utente (l'utente ha eseguito di nuovo il passaggio).	Chiamare sempre l'implementazione della classe super.
`OnRestoreInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Richiamato dopo `OnStart` la reinizializzazione dell'attività da uno stato salvato in precedenza.
`OnResume`	`Android.App.Activity`	Richiamato dopo `OnRestoreInstanceState`, `OnRestart`o `OnPause`per indicare che l'attività è attiva ed è pronta per ricevere l'input.
`OnSaveInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Richiamato per recuperare lo stato per istanza da un'attività terminata in modo che lo stato possa essere ripristinato in `OnCreate` o `OnRestoreInstanceState`.
`OnStart`	`Android.App.Activity`	Richiamato dopo `OnCreate` o `OnRestart` quando l'attività è stata arrestata, ma viene ora visualizzata all'utente.	Chiamare sempre l'implementazione della classe super.
`OnStop`	`Android.App.Activity`	Richiamato quando l'attività non è più visibile all'utente.	Chiamare sempre l'implementazione della classe super.

Importante

Ogni delegato ha un metodo di estensione denominato identico, che può essere chiamato per registrare un gestore per il delegato.

Per rispondere a un delegato del ciclo di vita Android richiamato, chiamare il ConfigureLifecycleEvents metodo sull'oggetto MauiAppBuilder nel CreateMauiapp metodo della MauiProgram classe. Quindi, nell'oggetto ILifecycleBuilder chiamare il AddAndroid metodo e specificare che Action registra i gestori per i delegati necessari:

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();
        }
    }
}

Per altre informazioni sul ciclo di vita dell'app Android, vedere Informazioni sul ciclo di vita delle attività in developer.android.com.

iOS

Nella tabella seguente sono elencati i delegati MAUI .NET richiamati in risposta agli eventi del ciclo di vita iOS generati:

Delega	Argomenti	Descrizione
`ApplicationSignificantTimeChange`	`UIKit.UIApplication`	Richiamato quando si verifica una modifica significativa dell'ora, ad esempio mezzanotte, ora modificata dal vettore o l'inizio o l'arresto dell'ora legale.
`ContinueUserActivity`	`UIKit.UIApplication`, `Foundation.NSUserActivity`, `UIKit.UIApplicationRestorationHandler`	Richiamato quando l'app riceve i dati associati a un'attività utente, ad esempio il trasferimento di un'attività da un dispositivo diverso tramite Handoff.
`DidEnterBackground`	`UIKit.UIApplication`	Richiamato quando l'app è entrata in background.
`FinishedLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Richiamato all'avvio dell'app.
`OnActivated`	`UIKit.UIApplication`	Richiamato all'avvio dell'app e ogni volta che l'app torna in primo piano.
`OnResignActivation`	`UIKit.UIApplication`	Richiamato quando l'app sta per entrare in background, essere sospesa o quando l'utente riceve un'interruzione, ad esempio una telefonata o un SMS.
`OpenUrl`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Richiamato quando l'app deve aprire un URL specificato.
`PerformActionForShortcutItem`	`UIKit.UIApplication`, `UIKit.UIApplicationShortcutItem`, `UIKit.UIOperationHandler`	Richiamato quando viene avviata un'azione rapida della schermata Home.
`PerformFetch`	`UIKit.UIApplication`, `Action<UIBackgroundFetchResult>`	Richiamato per indicare all'app che può avviare un'operazione di recupero se contiene dati da scaricare.
`SceneContinueUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Richiamato per gestire l'attività correlata all'handoff specificata.
`SceneDidDisconnect`	`UIKit.UIScene`	Richiamato quando una scena viene rimossa dall'app.
`SceneDidEnterBackground`	`UIKit.UIScene`	Richiamato quando una scena è in esecuzione in background e non è sullo schermo.
`SceneDidFailToContinueUserActivity`	`UIKit.UIScene`, `string`, `Foundation.NSError`	Richiamato per informare l'utente che non è stato possibile completare l'attività.
`SceneDidUpdateUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Richiamato quando l'attività specificata viene aggiornata.
`SceneOnActivated`	`UIKit.UIScene`	Richiamato quando la scena diventa attiva e in grado di rispondere agli eventi utente.
`SceneOnResignActivation`	`UIKit.UIScene`	Richiamato quando la scena sta per riassegnare lo stato attivo e interrompere la risposta agli eventi utente.
`SceneOpenUrl`	`UIKit.UIScene`, `Foundation.NSSet<UIKit.UIOpenUrlContext>`	Richiamato quando una scena chiede di aprire uno o più URL.
`SceneRestoreInteractionState`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Richiamato per ripristinare lo stato dell'attività.
`SceneWillConnect`	`UIKit.UIScene`, `UIKit.UISceneSession`, `UIKit.UISceneConnectionOptions`	Richiamato quando viene aggiunta una scena all'app.
`SceneWillContinueUserActivity`	`UIKit.UIScene`, `string`	Richiamato per preparare la ricezione dei dati correlati all'handoff.
`SceneWillEnterForeground`	`UIKit.UIScene`	Richiamato quando una scena sta per essere eseguita in primo piano e diventare visibile all'utente.
`WillEnterForeground`	`UIKit.UIApplication`	Richiamato se l'app verrà restituita da uno stato in background.
`WillFinishLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Richiamato all'avvio dell'app, ma il ripristino dello stato non è ancora stato eseguito.
`WillTerminate`	`UIKit.UIApplication`	Richiamato se l'app viene terminata a causa di vincoli di memoria o direttamente dall'utente.
`WindowSceneDidUpdateCoordinateSpace`	`UIKit.UIWindowScene`, `UIKit.IUICoordinateSpace`, `UIKit.UIInterfaceOrientationUIKit.UITraitCollection`	Richiamato quando cambiano le dimensioni, l'orientamento o i tratti di una scena.

Importante

Ogni delegato, ad eccezione di PerformFetch, ha un metodo di estensione con nome identico che può essere chiamato per registrare un gestore per il delegato.

Per rispondere a un delegato del ciclo di vita iOS richiamato, chiamare il ConfigureLifecycleEvents metodo sull'oggetto MauiAppBuilder nel CreateMauiapp metodo della MauiProgram classe. Quindi, nell'oggetto ILifecycleBuilder chiamare il AddiOS metodo e specificare che Action registra i gestori per i delegati necessari:

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();
        }
    }
}

Per altre informazioni sul ciclo di vita dell'app iOS, vedere Gestione del ciclo di vita dell'app in developer.apple.com.

Windows

La tabella seguente elenca i delegati MAUI .NET richiamati in risposta agli eventi del ciclo di vita di Windows generati:

Delega	Argomenti	Descrizione
`OnActivated`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowActivatedEventArgs`	Richiamato quando viene generato l'evento della piattaforma Activated , se l'app non riprende.
`OnClosed`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowEventArgs`	Richiamato quando viene generato l'evento della piattaforma Closed .
`OnLaunched`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Richiamato dall'override di Application.OnLaunched .NET MAUI dopo la creazione e l'attivazione della finestra nativa.
`OnLaunching`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Richiamato dall'override di .NET MAUI prima che Application.OnLaunched la finestra nativa sia stata creata e attivata.
`OnPlatformMessage`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformMessageEventArgs`	Richiamato quando .NET MAUI riceve messaggi nativi specifici di Windows.
`OnPlatformWindowSubclassed`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformWindowSubclassedEventArgs`	Richiamato da .NET MAUI quando la finestra Win32 è sottoclassata.
`OnResumed`	`Microsoft.UI.Xaml.Window`	Richiamato quando viene generato l'evento della piattaforma `Activated` , se l'app riprende.
`OnVisibilityChanged`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowVisibilityChangedEventArgs`	Richiamato quando viene generato l'evento della piattaforma VisibilityChanged .
`OnWindowCreated`	`Microsoft.UI.Xaml.Window`	Richiamato quando viene creata la finestra nativa per la piattaforma multipiattaforma `Window`.

.NET MAUI espone messaggi nativi specifici di Windows come evento del ciclo di vita con il OnPlatformMessage delegato . L'oggetto WindowsPlatformMessageEventArgs che accompagna questo delegato include una MessageId proprietà di tipo uint. Il valore di questa proprietà può essere esaminato per determinare quale messaggio è stato passato alla finestra dell'app. Per altre informazioni sui messaggi di Windows, vedere Messaggi di Windows (Introduzione a Win32 e C++). Per un elenco delle costanti dei messaggi della finestra, vedere Notifiche delle finestre.

Importante

Ogni delegato ha un metodo di estensione denominato identico, che può essere chiamato per registrare un gestore per il delegato.

Per rispondere a un delegato del ciclo di vita di Windows richiamato, chiamare il ConfigureLifecycleEvents metodo sull'oggetto MauiAppBuilder nel CreateMauiApp metodo della MauiProgram classe. Quindi, nell'oggetto ILifecycleBuilder chiamare il AddWindows metodo e specificare che Action registra i gestori per i delegati necessari:

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();
        }
    }
}

Recuperare l'oggetto Window

Il codice della piattaforma può recuperare l'oggetto dell'app dagli eventi del ciclo di vita della Window piattaforma, con il GetWindow metodo di estensione:

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();
        }
    }
}

Eventi del ciclo di vita personalizzati

Anche se .NET MAUI definisce delegati richiamati in risposta agli eventi del ciclo di vita della piattaforma generati, espone solo un set comune di eventi del ciclo di vita della piattaforma. Include tuttavia anche un meccanismo, in genere per gli autori di librerie, che consente alle app di ricevere notifiche quando vengono generati eventi aggiuntivi del ciclo di vita della piattaforma. A tale scopo, seguire questa procedura:

Registrare un gestore eventi per un evento del ciclo di vita della piattaforma che non è esposto da .NET MAUI.
Nel gestore eventi per l'evento del ciclo di vita della piattaforma recuperare l'istanza ILifecycleEventService e chiamarne InvokeEvents il metodo, specificando il nome dell'evento della piattaforma come argomento.

Quindi, le app che vogliono ricevere la notifica dell'evento del ciclo di vita della piattaforma devono modificare il CreateMauiApp metodo della relativa MauiProgram classe per chiamare il ConfigureLifecycleEvents metodo sull'oggetto MauiAppBuilder . Quindi, nell'oggetto ILifecycleBuilder chiamare il AddEvent metodo e specificare il nome dell'evento della piattaforma e l'oggetto Action che verrà richiamato quando viene generato l'evento della piattaforma.

Esempio

L'evento WinUI 3 Window.SizeChanged si verifica quando è stato eseguito il primo rendering della finestra dell'app nativa o ha modificato le dimensioni di rendering. .NET MAUI non espone questo evento della piattaforma come evento del ciclo di vita. Tuttavia, le app possono ricevere notifiche quando questo evento della piattaforma viene generato usando l'approccio seguente:

Registrare un gestore eventi per l'evento del ciclo di vita della Window.SizeChanged piattaforma:

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();
}

Nel gestore eventi per l'evento del ciclo di vita della piattaforma recuperare l'istanza ILifecycleEventService e chiamarne InvokeEvents il metodo, specificando il nome dell'evento della piattaforma come argomento:
```
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
```
Il MauiWinUIApplication tipo in Windows può essere usato per accedere all'istanza dell'app nativa tramite la relativa Current proprietà. Il MauiApplication tipo in Android può essere usato per accedere all'istanza dell'app nativa. Analogamente, il MauiUIApplicationDelegate tipo in iOS può essere usato per accedere all'istanza dell'app nativa.

Avviso

La chiamata di un evento non registrato, con il InvokeEvents metodo , non genera un'eccezione.

CreateMauiApp Nel metodo della MauiProgram classe chiamare il ConfigureLifecycleEvents metodo sull'oggetto MauiAppBuilder . Quindi, nell'oggetto ILifecycleBuilder chiamare il AddEvent metodo e specificare il nome dell'evento della piattaforma e che Action verrà richiamato quando viene generato l'evento della piattaforma:

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'effetto complessivo è che quando un utente modifica le dimensioni della finestra dell'app in Windows, viene eseguita l'azione specificata nel AddEvent metodo .

Nota

Il AddEvent metodo dispone inoltre di un overload che consente di specificare un delegato.

Condividi tramite

Ciclo di vita dell'app

Eventi del ciclo di vita multipiattaforma

Eventi del ciclo di vita della piattaforma

Android

iOS

Windows

Recuperare l'oggetto Window

Eventi del ciclo di vita personalizzati

Esempio

Commenti e suggerimenti

Risorse aggiuntive