Freigeben über

App-Lebenszyklus

  • Artikel

.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 = 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, OnRestartoder 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

In der folgenden Tabelle sind die .NET MAUI-Delegierten aufgeführt, die als Reaktion auf iOS-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 den Aufruf eines iOS-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 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
                    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.