App-Lebenszyklus

Artikel
10/31/2024

.NET Multi-platform App UI(.NET MAUI)-Apps haben im Allgemeinen vier Ausführungszustände: nicht ausgeführt, laufend, deaktiviert und gestoppt. NET MAUI löst plattformübergreifende Lebenszyklusereignisse für die Klasse Window aus, wenn eine App vom nicht laufenden Zustand in den laufenden Zustand, vom laufenden Zustand in den deaktivierten Zustand, vom deaktivierten Zustand in den gestoppten Zustand, vom gestoppten Zustand in den laufenden Zustand und vom gestoppten Zustand in den nicht laufenden Zustand übergeht.

Das folgende Diagramm zeigt einen Überblick über den Lösungslebenszyklus für diese beiden Ansätze:

.NET MAUI-App-Lebenszyklus

Im Diagramm gibt das graue Oval an, dass die App nicht in den Arbeitsspeicher geladen wird. Die hellblauen Ovale geben an, dass sich die App im Arbeitsspeicher befindet. Der Text auf den Bögen kennzeichnet Ereignisse, die von .NET MAUI ausgelöst werden und die laufende App benachrichtigen.

Der Ausführungszustand einer App hängt vom Verlauf der App ab. Wenn zum Beispiel eine App zum ersten Mal installiert oder ein Gerät gestartet wird, kann die App als nicht laufend betrachtet werden. Wenn die App gestartet wird, werden die Ereignisse Created und Activated ausgelöst und die App ist in Betrieb. Wenn ein anderes App-Fenster den Fokus erhält, wird das Deactivated-Ereignis ausgelöst und die App wird deaktiviert. Wechselt der Benutzer zu einer anderen App oder kehrt zum Home-Bildschirm des Geräts zurück, sodass das App-Fenster nicht mehr sichtbar ist, werden die Ereignisse Deactivated und Stopped ausgelöst und die App wird gestoppt. Wenn der Benutzer zur App zurückkehrt, wird das Resuming-Ereignis ausgelöst, und die App wird ausgeführt. Alternativ kann eine App von einem Benutzer beendet werden, während sie ausgeführt wird. In dieser Situation wird die App deaktiviert und dann gestoppt, das Ereignis Destroying wird ausgelöst und die App läuft nicht. Ebenso kann ein Gerät eine App beenden, während sie aufgrund von Ressourcenbeschränkungen gestoppt ist, und das Destroying-Ereignis wird ausgelöst und die App ist nicht in Betrieb.

Außerdem können Apps mit .NET MAUI benachrichtigt werden, wenn Plattform-Lebenszyklusereignisse ausgelöst werden. Weitere Informationen finden Sie unter Plattform-Lebenszyklus-Ereignisse.

Plattformübergreifende Lebenszyklusereignisse

Die Klasse Window definiert die folgenden plattformübergreifenden Lebenszyklusereignisse:

Ereignis	Beschreibung	Auszuführende Aktion
`Created`	Dieses Ereignis wird ausgelöst, nachdem das systemeigene Fenster erstellt wurde. An diesem Punkt verfügt das plattformübergreifende Fenster über einen systemeigenen Fensterhandler, aber das Fenster ist möglicherweise noch nicht sichtbar.
`Activated`	Dieses Ereignis wird ausgelöst, wenn das Fenster aktiviert wurde und das fokussierte Fenster ist oder wird.
`Deactivated`	Dieses Ereignis wird ausgelöst, wenn das Fenster nicht mehr das fokussierte Fenster ist. Das Fenster ist jedoch möglicherweise weiterhin sichtbar.
`Stopped`	Dieses Ereignis wird ausgelöst, wenn das Fenster nicht mehr sichtbar ist. Es gibt keine Garantie dafür, dass eine App aus diesem Zustand fortgesetzt wird, da sie möglicherweise vom Betriebssystem beendet wird.	Trennen Sie die Verbindung mit langen Prozessen, oder brechen Sie ausstehende Anforderungen ab, die Geräteressourcen verbrauchen könnten.
`Resumed`	Dieses Ereignis wird ausgelöst, wenn eine App nach dem Beenden fortgesetzt wird. Dieses Ereignis wird beim ersten Starten der App nicht ausgelöst und kann nur ausgelöst werden, wenn das `Stopped`-Ereignis zuvor ausgelöst wurde.	Abonnieren Sie alle erforderlichen Ereignisse, und aktualisieren Sie alle Inhalte auf der sichtbaren Seite.
`Destroying`	Dieses Ereignis wird ausgelöst, wenn das systemeigene Fenster zerstört und verarbeitet wird. Dasselbe plattformübergreifende Fenster kann für ein neues systemeigenes Fenster verwendet werden, wenn die App erneut geöffnet wird.	Entfernen Sie alle Ereignisabonnements, die Sie an das systemeigene Fenster angefügt haben.

Diese plattformübergreifenden Ereignisse sind verschiedenen Plattformereignissen zugeordnet, und die folgende Tabelle zeigt diese Zuordnung:

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

Darüber hinaus definiert die Window-Klasse auch ein Backgrounding-Ereignis, das unter iOS und Mac Catalyst ausgelöst wird, wenn das Fenster geschlossen oder in einen Hintergrundzustand wechselt. Ein BackgroundingEventArgs-Objekt begleitet dieses Ereignis, und jeder string-Zustand sollte in der State-Eigenschaft des BackgroundingEventArgs-Objekts persistiert werden, die das Betriebssystem beibehält, bis es Zeit ist, das Fenster wieder aufzunehmen. Wenn das Fenster wieder aufgenommen wird, wird der Zustand durch das IActivationState-Argument des CreateWindow-Override bereitgestellt.

Zusätzlich zu diesen Ereignissen verfügt die Klasse Window auch über die folgenden überschreibbaren Lebenszyklusmethoden:

OnCreated wird aufgerufen, wenn das Created-Ereignis ausgelöst wird.
OnActivated wird aufgerufen, wenn das Activated-Ereignis ausgelöst wird.
OnDeactivated wird aufgerufen, wenn das Deactivated-Ereignis ausgelöst wird.
OnStopped wird aufgerufen, wenn das Stopped-Ereignis ausgelöst wird.
OnResumed wird aufgerufen, wenn das Resumed-Ereignis ausgelöst wird.
OnDestroying wird aufgerufen, wenn das Destroying-Ereignis ausgelöst wird.
OnBackgrounding wird aufgerufen, wenn das Backgrounding-Ereignis ausgelöst wird.

Um die Window-Lebenszyklus-Ereignisse zu abonnieren, überschreiben Sie die CreateWindow-Methode in Ihrer App-Klasse, um eine Window-Instanz zu erstellen, für die Sie Ereignisse abonnieren können:

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

Alternativ können Sie eine Klasse erstellen, die von der Klasse Window abgeleitet ist, um die Überschreibungen des Lebenszyklus zu nutzen

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

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

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

Die Window-abgeleitete Klasse kann dann verwendet werden, indem die CreateWindow-Methode in Ihrer App-Klasse überschrieben wird, um eine MyWindow-Instanz zurückzugeben.

Warnung

Ein InvalidOperationException wird ausgelöst, wenn die App.MainPage-Eigenschaft gesetzt ist und die CreateWindow-Methode ein Window-Objekt mit dem Override erzeugt, das ein Page-Argument akzeptiert.

Plattformlebenszyklusereignisse

NET MAUI definiert Delegierte, die als Reaktion auf ausgelöste Plattform-Lebenszyklusereignisse aufgerufen werden. Für diese Delegaten können Handler mit benannten Methoden oder anonymen Funktionen angegeben werden, die ausgeführt werden, wenn der Delegat aufgerufen wird. Mit diesem Mechanismus können Apps benachrichtigt werden, wenn allgemeine Plattform-Lebenszyklusereignisse ausgelöst werden.

Wichtig

Das ConfigureLifecycleEvents-Element befindet sich im Microsoft.Maui.LifecycleEvents-Namespace.

Android

In der folgenden Tabelle sind die .NET MAUI-Delegierten aufgeführt, die als Reaktion auf ausgelöste Android-Lebenszyklusereignisse aufgerufen werden:

Delegieren	Argumente	Beschreibung	Kommentare
`OnActivityResult`	`Android.App.Activity`, `int`, `Android.App.Result`, `Android.Content.Intent?`	Wird aufgerufen, wenn eine Aktivität, die Sie gestartet haben, beendet wird.
`OnApplicationConfigurationChanged`	`Android.App.Application`, `Android.Content.Res.Configuration`	Wird aufgerufen, wenn sich die Gerätekonfiguration ändert, während die Komponente ausgeführt wird.
`OnApplicationCreate`	`Android.App.Application`	Wird aufgerufen, wenn die App gestartet wurde, bevor ein Aktivitäts-, Dienst- oder Empfängerobjekt (mit Ausnahme von Inhaltsanbietern) erstellt wurde.
`OnApplicationCreating`	`Android.App.Application`	Wird aufgerufen, wenn die App gestartet wird, bevor ein Aktivitäts-, Dienst- oder Empfängerobjekt (mit Ausnahme von Inhaltsanbietern) erstellt wurde.
`OnApplicationLowMemory`	`Android.App.Application`	Wird aufgerufen, wenn das System nicht genügend Arbeitsspeicher hat, und aktive Prozesse sollten die Speicherauslastung kürzen.
`OnApplicationTrimMemory`	`Android.App.Application`, `Android.Content.TrimMemory`	Wird aufgerufen, wenn das Betriebssystem festgestellt hat, dass es eine gute Zeit für einen Prozess ist, nicht benötigte Arbeitsspeicher aus dem Prozess zu kürzen.
`OnBackPressed`	`Android.App.Activity`	Wird aufgerufen, wenn die Aktivität ein Drücken der Rücktaste erkannt hat.
`OnConfigurationChanged`	`Android.App.Activity`, `Android.Content.Res.Configuration`	Wird aufgerufen, wenn sich die Gerätekonfiguration ändert, während Ihre Aktivität ausgeführt wird.
`OnCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Wird ausgelöst, wenn die Aktivität erstellt wird.
`OnDestroy`	`Android.App.Activity`	Wird aufgerufen, wenn die Aktivität beendet wird oder das System die Aktivitätsinstanz vorübergehend zerstört, um Platz zu sparen.	Rufen Sie immer die Implementierung der Superklasse auf.
`OnNewIntent`	`Android.App.Activity`, `Android.Content.Intent?`	Wird aufgerufen, wenn die Aktivität neu gestartet wird, anstatt eine neue Instanz der Aktivität, die gestartet wird, am Anfang des Aktivitätsstapels.
`OnPause`	`Android.App.Activity`	Wird aufgerufen, wenn eine Aktivität in den Hintergrund geht, aber noch nicht beendet wurde.	Rufen Sie immer die Implementierung der Superklasse auf.
`OnPostCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Wird aufgerufen, wenn der Aktivitätsstart abgeschlossen ist, nachdem `OnStart` und `OnRestoreInstanceState` aufgerufen wurden.	Rufen Sie immer die Implementierung der Superklasse auf. Dies ist ein systemgeschütztes Ereignis, das in der Regel nicht von Apps verwendet werden sollte.
`OnPostResume`	`Android.App.Activity`	Wird aufgerufen, wenn die Wiederaufnahme der Aktivität abgeschlossen ist, nachdem `OnResume` aufgerufen wurde.	Rufen Sie immer die Implementierung der Superklasse auf. Dies ist ein systemgeschütztes Ereignis, das in der Regel nicht von Apps verwendet werden sollte.
`OnRequestPermissionsResult`	`Android.App.Activity`, `int`, `string[]`, `Android.Content.PM.Permission[]`	Wird als Rückruf für das Ergebnis aufgerufen, indem Berechtigungen angefordert werden.
`OnRestart`	`Android.App.Activity`	Wird nach `OnStop` aufgerufen, wenn die aktuelle Aktivität dem Benutzer erneut angezeigt wird (der Benutzer hat zu ihr zurück navigiert).	Rufen Sie immer die Implementierung der Superklasse auf.
`OnRestoreInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Wird aufgerufen, nachdem `OnStart` die Aktivität aus einem zuvor gespeicherten Zustand neu initialisiert wird.
`OnResume`	`Android.App.Activity`	Wird nach `OnRestoreInstanceState`, `OnRestart`oder `OnPause`, aufgerufen, um anzugeben, dass die Aktivität aktiv ist und bereit für den Empfang von Eingaben ist.
`OnSaveInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Wird aufgerufen, um den Zustand pro Instanz von einer Aktivität abzurufen, die beendet wird, damit der Zustand in `OnCreate` oder `OnRestoreInstanceState` wiederhergestellt werden kann.
`OnStart`	`Android.App.Activity`	Wird nach `OnCreate` oder `OnRestart` aufgerufen, wenn die Aktivität gestoppt wurde, aber jetzt dem Benutzer angezeigt wird.	Rufen Sie immer die Implementierung der Superklasse auf.
`OnStop`	`Android.App.Activity`	Wird aufgerufen, wenn die Aktivität für den Benutzer nicht mehr sichtbar ist.	Rufen Sie immer die Implementierung der Superklasse auf.

Wichtig

Jeder Delegat verfügt über eine entsprechende, identisch benannte Erweiterungsmethode, die aufgerufen werden kann, um einen Handler für den Delegaten zu registrieren.

Um auf den Aufruf eines Android-Lifecycle-Delegaten zu reagieren, rufen Sie die ConfigureLifecycleEvents-Methode für das MauiAppBuilder-Objekt in der CreateMauiapp-Methode Ihrer MauiProgram-Klasse auf. Rufen Sie dann auf dem ILifecycleBuilder-Objekt die AddAndroid-Methode auf und geben Sie den Action an, der die Handler für die erforderlichen Delegierten registriert:

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

Weitere Informationen über den Lebenszyklus von Android-Apps finden Sie unter Verstehen Sie den Aktivitätslebenszyklus auf developer.android.com.

iOS und Mac Catalyst

In der folgenden Tabelle sind die .NET MAUI-Delegaten aufgeführt, die als Reaktion auf ausgelöste iOS- und Mac Catalyst-Lebenszyklusereignisse aufgerufen werden:

Delegieren	Argumente	Beschreibung
`ApplicationSignificantTimeChange`	`UIKit.UIApplication`	Wird aufgerufen, wenn eine bedeutende Zeitänderung eintritt, wie etwa Mitternacht, Zeitumstellung des Trägers oder Beginn oder Ende der Sommerzeit.
`ContinueUserActivity`	`UIKit.UIApplication`, `Foundation.NSUserActivity`, `UIKit.UIApplicationRestorationHandler`	Wird aufgerufen, wenn die App Daten im Zusammenhang mit einer Benutzeraktivität empfängt, wie etwa beim Übertragen einer Aktivität von einem anderen Gerät mit Handoff.
`DidEnterBackground`	`UIKit.UIApplication`	Wird aufgerufen, wenn die App den Hintergrund eingegeben hat.
`FinishedLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Wird aufgerufen, wenn die App gestartet wurde.
`OnActivated`	`UIKit.UIApplication`	Wird aufgerufen, wenn die App gestartet wird und jedes Mal, wenn die App in den Vordergrund zurückkehrt.
`OnResignActivation`	`UIKit.UIApplication`	Wird aufgerufen, wenn die App in den Hintergrund tritt, angehalten wird oder wenn der Benutzer eine Unterbrechung erhält, z. B. einen Anruf oder eine SMS.
`OpenUrl`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Wird aufgerufen, wenn die App eine angegebene URL öffnen soll.
`PerformActionForShortcutItem`	`UIKit.UIApplication`, `UIKit.UIApplicationShortcutItem`, `UIKit.UIOperationHandler`	Wird aufgerufen, wenn eine schnelle Aktion auf dem Startbildschirm initiiert wird.
`PerformFetch`	`UIKit.UIApplication`, `Action<UIBackgroundFetchResult>`	Wird aufgerufen, um der App mitzuteilen, dass sie einen Abrufvorgang starten kann, wenn sie Daten zum Herunterladen enthält.
`SceneContinueUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Wird aufgerufen, um die angegebene Handoff-bezogene Aktivität zu behandeln.
`SceneDidDisconnect`	`UIKit.UIScene`	Wird aufgerufen, wenn eine Szene aus der App entfernt wird.
`SceneDidEnterBackground`	`UIKit.UIScene`	Wird aufgerufen, wenn eine Szene im Hintergrund ausgeführt wird und sich nicht auf dem Bildschirm befindet.
`SceneDidFailToContinueUserActivity`	`UIKit.UIScene`, `string`, `Foundation.NSError`	Wird aufgerufen, um den Benutzer darüber zu informieren, dass die Aktivität nicht abgeschlossen werden konnte.
`SceneDidUpdateUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Wird aufgerufen, wenn die angegebene Aktivität aktualisiert wird.
`SceneOnActivated`	`UIKit.UIScene`	Wird aufgerufen, wenn die Szene aktiv wird und auf Benutzerereignisse reagieren kann.
`SceneOnResignActivation`	`UIKit.UIScene`	Wird aufgerufen, wenn die Szene in der Lage ist, den aktiven Zustand neu zuzuweisen und nicht mehr auf Benutzerereignisse zu reagieren.
`SceneOpenUrl`	`UIKit.UIScene`, `Foundation.NSSet<UIKit.UIOpenUrlContext>`	Wird aufgerufen, wenn eine Szene aufgefordert wird, eine oder mehrere URLs zu öffnen.
`SceneRestoreInteractionState`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Wird aufgerufen, um den Aktivitätszustand wiederherzustellen.
`SceneWillConnect`	`UIKit.UIScene`, `UIKit.UISceneSession`, `UIKit.UISceneConnectionOptions`	Wird aufgerufen, wenn der App eine Szene hinzugefügt wird.
`SceneWillContinueUserActivity`	`UIKit.UIScene`, `string`	Wird aufgerufen, um den Empfang von Handoff-bezogenen Daten vorzubereiten.
`SceneWillEnterForeground`	`UIKit.UIScene`	Wird aufgerufen, wenn eine Szene im Vordergrund ausgeführt wird und für den Benutzer sichtbar wird.
`WillEnterForeground`	`UIKit.UIApplication`	Wird aufgerufen, wenn die App aus einem Hintergrundzustand zurückgegeben wird.
`WillFinishLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Wird aufgerufen, wenn der Start der App begonnen hat, die Wiederherstellung des Status aber noch nicht erfolgt ist.
`WillTerminate`	`UIKit.UIApplication`	Wird aufgerufen, wenn die App aufgrund von Speichereinschränkungen oder direkt vom Benutzer beendet wird.
`WindowSceneDidUpdateCoordinateSpace`	`UIKit.UIWindowScene`, `UIKit.IUICoordinateSpace`, `UIKit.UIInterfaceOrientation`, `UIKit.UITraitCollection`	Wird aufgerufen, wenn sich die Größe, die Ausrichtung oder die Eigenschaften einer Szene ändern.

Wichtig

Jeder Delegat, mit Ausnahme von PerformFetch, hat eine entsprechende, gleichnamige Erweiterungsmethode, die aufgerufen werden kann, um einen Handler für den Delegaten zu registrieren.

Um auf einen aufgerufenen iOS- und Mac Catalyst-Lebenszyklusdelegaten zu reagieren, rufen Sie die ConfigureLifecycleEvents-Methode für das MauiAppBuilder-Objekt in der CreateMauiapp-Methode Ihrer MauiProgram-Klasse auf. Rufen Sie dann auf dem ILifecycleBuilder-Objekt die AddiOS-Methode auf und geben Sie die Action an, die die Handler für die erforderlichen Delegierten registriert:

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

Weitere Informationen über den Lebenszyklus von iOS-Apps finden Sie unter Verwalten des Lebenszyklus Ihrer App auf developer.apple.com.

Windows

In der folgenden Tabelle sind die .NET MAUI-Delegaten aufgeführt, die als Reaktion auf ausgelöste Windows-Lebenszyklusereignisse aufgerufen werden:

Delegieren	Argumente	Beschreibung
`OnActivated`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowActivatedEventArgs`	Wird aufgerufen, wenn das Plattform-Activated-Ereignis ausgelöst wird, wenn die App nicht fortgesetzt wird.
`OnClosed`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowEventArgs`	Wird aufgerufen, wenn das Plattform-Closed-Ereignis ausgelöst wird
`OnLaunched`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Aufgerufen durch den Application.OnLaunched Override von .NET MAUI, sobald das native Fenster erstellt und aktiviert wurde
`OnLaunching`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Aufgerufen durch den Application.OnLaunched Override von .NET MAUI, bevor das native Fenster erstellt und aktiviert wurde
`OnPlatformMessage`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformMessageEventArgs`	Wird aufgerufen, wenn .NET MAUI bestimmte systemeigene Windows-Nachrichten empfängt.
`OnPlatformWindowSubclassed`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformWindowSubclassedEventArgs`	Wird von .NET MAUI aufgerufen, wenn das Win32-Fenster unterklassigt ist.
`OnResumed`	`Microsoft.UI.Xaml.Window`	Wird aufgerufen, wenn das Plattform-`Activated`-Ereignis ausgelöst wird, wenn die App fortgesetzt wird.
`OnVisibilityChanged`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowVisibilityChangedEventArgs`	Wird aufgerufen, wenn das Plattform-VisibilityChanged-Ereignis ausgelöst wird
`OnWindowCreated`	`Microsoft.UI.Xaml.Window`	Wird aufgerufen, wenn das native Fenster für die plattformübergreifende `Window` erstellt wird.

NET MAUI stellt bestimmte native Windows-Nachrichten als Lebenszyklus-Ereignis mit dem OnPlatformMessage-Delegat dar. Das WindowsPlatformMessageEventArgs-Objekt, das diesen Delegaten begleitet, enthält eine MessageId-Eigenschaft vom Typ uint. Der Wert dieser Eigenschaft kann untersucht werden, um zu bestimmen, welche Nachricht an ihr App-Fenster übergeben wurde. Weitere Informationen über Windows-Meldungen finden Sie unter Windows-Meldungen (Erste Schritte mit Win32 und C++). Für eine Liste von Fenstermeldungskonstanten, siehe Fenstermeldungen.

Wichtig

Jeder Delegat verfügt über eine entsprechende, identisch benannte Erweiterungsmethode, die aufgerufen werden kann, um einen Handler für den Delegaten zu registrieren.

Um auf den Aufruf eines Windows-Lebenszyklus-Delegaten zu reagieren, rufen Sie die ConfigureLifecycleEvents-Methode für das MauiAppBuilder-Objekt in der CreateMauiApp-Methode Ihrer MauiProgram-Klasse auf. Rufen Sie dann auf dem ILifecycleBuilder-Objekt die AddWindows-Methode auf und geben Sie den Action an, der die Handler für die erforderlichen Delegierten registriert:

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

Abrufen des Window-Objekts

Plattform-Code kann das Window-Objekt der App aus Plattform-Lebenszyklus-Ereignissen mit der GetWindow-Erweiterungsmethode abrufen:

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

Benutzerdefinierte Lebenszyklusereignisse

Während .NET MAUI Delegaten definiert, die als Reaktion auf ausgelöste Plattformlebenszyklusereignisse aufgerufen werden, macht sie nur einen allgemeinen Satz von Plattformlebenszyklusereignissen verfügbar. Es enthält jedoch auch einen Mechanismus, der in der Regel für Bibliotheksautoren verwendet wird, mit dem Apps benachrichtigt werden können, wenn zusätzliche Plattformlebenszyklusereignisse ausgelöst werden. Die Vorgehensweise hierfür ist wie folgt:

Registrieren Sie einen Event-Handler für ein Plattform-Lebenszyklus-Ereignis, das nicht von .NET MAUI bereitgestellt wird.
Rufen Sie im Event-Handler für das Plattform-Lebenszyklus-Ereignis die ILifecycleEventService-Instanz ab und rufen Sie ihre InvokeEvents-Methode auf, wobei Sie den Namen des Plattform-Ereignisses als Argument angeben.

Dann sollten Apps, die eine Benachrichtigung über das Plattform-Lebenszyklus-Ereignis erhalten möchten, die CreateMauiApp-Methode ihrer MauiProgram-Klasse so ändern, dass sie die ConfigureLifecycleEvents-Methode für das MauiAppBuilder-Objekt aufrufen. Rufen Sie dann im ILifecycleBuilder-Objekt die AddEvent-Methode auf und geben Sie den Namen des Plattformereignisses und den Action an, der aufgerufen wird, wenn das Plattformereignis ausgelöst wird.

Beispiel

Das WinUI 3Window.SizeChanged-Ereignis tritt ein, wenn das Fenster der nativen App zum ersten Mal gerendert wurde oder seine Größe geändert hat. .NET MAUI macht dieses Plattformereignis nicht als Lebenszyklusereignis verfügbar. Apps können jedoch Benachrichtigungen empfangen, wenn dieses Plattformereignis mithilfe des folgenden Ansatzes ausgelöst wird:

Registrieren sie einen Ereignishandler für das Window.SizeChanged-Plattformlebenszyklusereignis:

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

Rufen Sie im Event-Handler für das Plattform-Lebenszyklus-Ereignis die ILifecycleEventService-Instanz ab und rufen Sie ihre InvokeEvents-Methode auf, wobei Sie den Namen des Plattform-Ereignisses als Argument angeben:
```
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
```
Der MauiWinUIApplication-Typ unter Windows kann verwendet werden, um über seine Current-Eigenschaft auf die native App-Instanz zuzugreifen. Der MauiApplication-Typ auf Android kann für den Zugriff auf die native App-Instanz verwendet werden. In ähnlicher Weise kann der Typ MauiUIApplicationDelegate unter iOS für den Zugriff auf die native App-Instanz verwendet werden.

Warnung

Das Aufrufen eines nicht registrierten Ereignisses mit der Methode InvokeEvents löst keine Ausnahme aus.

Rufen Sie in der Methode CreateMauiApp Ihrer Klasse MauiProgram die Methode ConfigureLifecycleEvents des Objekts MauiAppBuilder auf. Rufen Sie dann im ILifecycleBuilder-Objekt die AddEvent-Methode auf und geben Sie den Namen des Plattformereignisses und den Action an, der aufgerufen wird, wenn das Plattformereignis ausgelöst wird:

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

Der Gesamteffekt ist, dass die in der AddEvent-Methode angegebene Aktion ausgeführt wird, wenn ein Benutzer die Fenstergröße der App unter Windows ändert.

Hinweis

Die Methode AddEvent hat auch eine Überladung, die die Angabe eines Delegaten ermöglicht.

Freigeben über

App-Lebenszyklus

Plattformübergreifende Lebenszyklusereignisse

Plattformlebenszyklusereignisse

Android

iOS und Mac Catalyst

Windows

Abrufen des Window-Objekts

Benutzerdefinierte Lebenszyklusereignisse

Beispiel

Zusätzliche Ressourcen