Životní cyklus aplikace

Článek
05/14/2024

Aplikace .NET Multi-Platform App UI (.NET MAUI) mají obecně čtyři stavy spuštění: neběží, neběží, deaktivuje a zastaví. .NET MAUI vyvolává události životního cyklu napříč platformami ve Window třídě, když aplikace přejde z nespouštět stavu do spuštěného stavu, stav spuštění do deaktivovaného stavu, deaktivovaný stav do zastaveného stavu, zastavený stav do spuštěného stavu a zastavený stav do stavu, který není spuštěný.

Následující diagram znázorňuje přehled životního cyklu aplikace .NET MAUI:

Životní cyklus aplikace .NET MAUI

V diagramu šedý ovál označuje, že aplikace není načtena do paměti. Světle modré ovály označují, že aplikace je v paměti. Text na obloukech označuje události vyvolané rozhraním .NET MAUI, které poskytují oznámení spuštěné aplikaci.

Stav spuštění aplikace závisí na historii aplikace. Například při prvním spuštění aplikace nebo spuštění zařízení je možné aplikaci považovat za nespouštět. Po spuštění Created aplikace se vyvolá události Activated a aplikace je spuštěná. Pokud se zaměří jiné okno aplikace, Deactivated vyvolá se událost a aplikace se deaktivuje. Pokud uživatel přepne na jinou aplikaci nebo se vrátí na domovskou obrazovku zařízení, aby okno aplikace nebylo viditelné, Deactivated vyvolá se události a Stopped aplikace se zastavila. Pokud se uživatel vrátí do aplikace, Resuming vyvolá se událost a aplikace je spuštěná. Případně může být aplikace ukončena uživatelem, když je spuštěná. V takovém případě se aplikace deaktivuje a pak se zastaví, Destroying událost se vyvolá a aplikace není spuštěná. Podobně může zařízení ukončit aplikaci, když je zastavená, kvůli omezením prostředků a Destroying událost se vyvolá a aplikace není spuštěná.

Kromě toho rozhraní .NET MAUI umožňuje aplikacím dostávat oznámení při vyvolání událostí životního cyklu platformy. Další informace najdete v tématu Události životního cyklu platformy.

Události životního cyklu napříč platformami

Třída Window definuje následující události životního cyklu napříč platformami:

Událost	Popis	Akce, která se má provést
`Created`	Tato událost se vyvolá po vytvoření nativního okna. V tomto okamžiku bude okno pro různé platformy obsahovat nativní obslužnou rutinu okna, ale okno ještě nemusí být viditelné.
`Activated`	Tato událost se vyvolá, když je okno aktivováno a je nebo se stane prioritním oknem.
`Deactivated`	Tato událost se vyvolá, když okno již není prioritním oknem. Okno ale může být stále viditelné.
`Stopped`	Tato událost se vyvolá, když okno již není viditelné. Neexistuje žádná záruka, že aplikace bude pokračovat z tohoto stavu, protože může být ukončena operačním systémem.	Odpojte se od jakýchkoli dlouhotrvajících procesů nebo zrušte všechny čekající požadavky, které můžou spotřebovávat prostředky zařízení.
`Resumed`	Tato událost se vyvolá, když se aplikace po zastavení obnoví. Tato událost se při prvním spuštění aplikace nevyvolá a může být vyvolána pouze v případě, že `Stopped` byla událost vyvolána dříve.	Přihlaste se k odběru všech požadovaných událostí a aktualizujte veškerý obsah, který je na viditelné stránce.
`Destroying`	Tato událost se vyvolá při zničení a uvolnění nativního okna. Stejné okno pro různé platformy se může použít pro nové nativní okno při opětovném otevření aplikace.	Odeberte všechna odběry událostí, která jste připojili k nativnímu okně.

Tyto události napříč platformami se mapují na různé události platformy a následující tabulka ukazuje toto mapování:

Událost	Android	iOS	Okna
`Created`	`OnPostCreate`	`FinishedLaunching`	`Created`
`Activated`	`OnResume`	`OnActivated`	`Activated` (`CodeActivated` a `PointerActivated`)
`Deactivated`	`OnPause`	`OnResignActivation`	`Activated` (`Deactivated`)
`Stopped`	`OnStop`	`DidEnterBackground`	`VisibilityChanged`
`Resumed`	`OnRestart`	`WillEnterForeground`	`Resumed`
`Destroying`	`OnDestroy`	`WillTerminate`	`Closed`

Kromě toho třída také definuje Backgrounding událost, Window která je vyvolána v systému iOS a Mac Catalyst při zavření okna nebo vstup do stavu pozadí. Objekt BackgroundingEventArgs doprovází tuto událost a jakýkoli string stav by měl být zachován na State vlastnost objektu BackgroundingEventArgs , kterou operační systém zachová, dokud nebude čas obnovit okno. Po obnovení okna je stav poskytnut IActivationState argumentem přepsání CreateWindow .

Kromě těchto událostí Window má třída také následující přepisovatelné metody životního cyklu:

OnCreated, který se vyvolá při Created vyvolání události.
OnActivated, který se vyvolá při Activated vyvolání události.
OnDeactivated, který se vyvolá při Deactivated vyvolání události.
OnStopped, který se vyvolá při Stopped vyvolání události.
OnResumed, který se vyvolá při Resumed vyvolání události.
OnDestroying, který se vyvolá při Destroying vyvolání události.
OnBackgrounding, který se vyvolá při Backgrounding vyvolání události.

Pokud se chcete přihlásit k odběru Window událostí životního cyklu, přepište CreateWindow metodu ve třídě App a vytvořte Window instanci, na které se můžete přihlásit k odběru událostí:

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

Pokud chcete případně využívat přepsání životního cyklu, vytvořte třídu, která je odvozena od Window třídy.

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

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

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

Window-odvozenou třídu pak lze využít přepsáním CreateWindow metody ve vaší App třídě k vrácení MyWindow instance.

Upozorňující

Bude InvalidOperationException vyvolán, pokud App.MainPage je vlastnost nastavena a CreateWindow metoda vytvoří Window objekt pomocí přepsání, který přijímá Page argument.

Události životního cyklu platformy

.NET MAUI definuje delegáty, které jsou vyvolány v reakci na události životního cyklu platformy, které jsou vyvolány. Obslužné rutiny lze pro tyto delegáty zadat pomocí pojmenovaných metod nebo anonymních funkcí, které se spustí při vyvolání delegáta. Tento mechanismus umožňuje aplikacím dostávat oznámení při vyvolání běžných událostí životního cyklu platformy.

Důležité

Metoda ConfigureLifecycleEvents je v Microsoft.Maui.LifecycleEvents oboru názvů.

Android

Následující tabulka uvádí delegáty .NET MAUI, které jsou vyvolány v reakci na vyvolání událostí životního cyklu Androidu:

Delegát	Argumenty	Popis	Komentáře
`OnActivityResult`	`Android.App.Activity`, `int`, , `Android.App.ResultAndroid.Content.Intent?`	Vyvolána při spuštění aktivity se ukončí.
`OnApplicationConfigurationChanged`	`Android.App.Application`, `Android.Content.Res.Configuration`	Vyvolá se, když se konfigurace zařízení změní, když je vaše komponenta spuštěná.
`OnApplicationCreate`	`Android.App.Application`	Vyvoláno při spuštění aplikace před vytvořením aktivity, služby nebo objektu příjemce (s výjimkou poskytovatelů obsahu).
`OnApplicationCreating`	`Android.App.Application`	Vyvoláno při spuštění aplikace před vytvořením aktivity, služby nebo objektu příjemce (s výjimkou poskytovatelů obsahu).
`OnApplicationLowMemory`	`Android.App.Application`	Vyvoláno, když systém nemá dostatek paměti a aktivně spuštěné procesy by měly oříznout využití paměti.
`OnApplicationTrimMemory`	`Android.App.Application`, `Android.Content.TrimMemory`	Vyvoláno, když operační systém zjistil, že je vhodná doba, kdy proces ořízne nepotřebnou paměť z procesu.
`OnBackPressed`	`Android.App.Activity`	Vyvoláno, když aktivita zjistila stisknutí zadní klávesy.
`OnConfigurationChanged`	`Android.App.Activity`, `Android.Content.Res.Configuration`	Vyvolá se, když se konfigurace zařízení změní, když je vaše aktivita spuštěná.
`OnCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Vyvolá se při vytvoření aktivity.
`OnDestroy`	`Android.App.Activity`	Vyvolá se při dokončení aktivity nebo protože systém dočasně zničí instanci aktivity, aby ušetřil místo.	Vždy volejte implementaci supertřídy.
`OnNewIntent`	`Android.App.Activity`, `Android.Content.Intent?`	Vyvolá se při opětovném spuštění aktivity v horní části zásobníku aktivit místo nové instance spuštěné aktivity.
`OnPause`	`Android.App.Activity`	Vyvoláno, když aktivita přejde na pozadí, ale ještě nebyla zabita.	Vždy volejte implementaci supertřídy.
`OnPostCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Vyvoláno po dokončení `OnStart` spuštění aktivity a `OnRestoreInstanceState` po zavolání.	Vždy volejte implementaci supertřídy. Jedná se o systémovou událost, která by obecně neměla být používána aplikacemi.
`OnPostResume`	`Android.App.Activity`	Vyvoláno při dokončení obnovení aktivity po `OnResume` zavolání.	Vždy volejte implementaci supertřídy. Jedná se o systémovou událost, která by obecně neměla být používána aplikacemi.
`OnRequestPermissionsResult`	`Android.App.Activity`, `int`, , `string[]Android.Content.PM.Permission[]`	Vyvoláno jako zpětné volání pro výsledek žádosti o oprávnění.
`OnRestart`	`Android.App.Activity`	Vyvoláno po `OnStop` opětovném zobrazení aktuální aktivity uživateli (uživatel se k ní vrátil).	Vždy volejte implementaci supertřídy.
`OnRestoreInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Vyvoláno po `OnStart` opětovné inicializaci aktivity z dříve uloženého stavu.
`OnResume`	`Android.App.Activity`	Vyvoláno po `OnRestoreInstanceState`, `OnRestart`nebo `OnPause`, indikuje, že aktivita je aktivní a je připravena přijímat vstup.
`OnSaveInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Vyvoláno pro načtení stavu jednotlivých instancí z aktivity, která je zabita, aby stav mohl být obnoven v `OnCreate` nebo `OnRestoreInstanceState`.
`OnStart`	`Android.App.Activity`	Vyvolána po `OnCreate` ukončení nebo `OnRestart` po zastavení aktivity, ale nyní se uživateli zobrazuje.	Vždy volejte implementaci supertřídy.
`OnStop`	`Android.App.Activity`	Vyvoláno v případě, že aktivita již není viditelná pro uživatele.	Vždy volejte implementaci supertřídy.

Důležité

Každý delegát má odpovídající identickou metodu rozšíření, kterou lze volat k registraci obslužné rutiny pro delegáta.

Pokud chcete odpovědět na vyvolání delegáta životního cyklu Androidu, zavolejte ConfigureLifecycleEvents metodu MauiAppBuilder na objektu v CreateMauiapp metodě třídy MauiProgram . Pak v objektu ILifecycleBuilder zavolejte metodu AddAndroid a určete Action , která registruje obslužné rutiny pro požadované delegáty:

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

Další informace o životním cyklu aplikace pro Android najdete v tématu Vysvětlení životního cyklu aktivity na developer.android.com.

iOS

Následující tabulka uvádí delegáty .NET MAUI, které jsou vyvolány v reakci na vyvolání událostí životního cyklu iOSu:

Delegát	Argumenty	Popis
`ApplicationSignificantTimeChange`	`UIKit.UIApplication`	Vyvoláno, když dojde k významné změně času, jako je půlnoc, čas změny operátora nebo začátek nebo zastavení letního času.
`ContinueUserActivity`	`UIKit.UIApplication`, , `Foundation.NSUserActivityUIKit.UIApplicationRestorationHandler`	Vyvolá se, když aplikace obdrží data přidružená k aktivitě uživatele, například přenos aktivity z jiného zařízení pomocí handoffu.
`DidEnterBackground`	`UIKit.UIApplication`	Vyvoláno, když aplikace přešla na pozadí.
`FinishedLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Vyvoláno při spuštění aplikace.
`OnActivated`	`UIKit.UIApplication`	Vyvolá se při spuštění aplikace a pokaždé, když se aplikace vrátí do popředí.
`OnResignActivation`	`UIKit.UIApplication`	Vyvolá se, když se aplikace chystá zadat pozadí, pozastavit nebo když uživatel obdrží přerušení, jako je telefonní hovor nebo text.
`OpenUrl`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Vyvoláno, když by aplikace měla otevřít zadanou adresu URL.
`PerformActionForShortcutItem`	`UIKit.UIApplication`, , `UIKit.UIApplicationShortcutItemUIKit.UIOperationHandler`	Vyvolána při zahájení rychlé akce na domovské obrazovce.
`PerformFetch`	`UIKit.UIApplication`, `Action<UIBackgroundFetchResult>`	Vyvolá se, aby aplikaci oznámila, že může zahájit operaci načítání, pokud má data ke stažení.
`SceneContinueUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Vyvolána pro zpracování zadané aktivity související s předáním.
`SceneDidDisconnect`	`UIKit.UIScene`	Vyvoláno při odebrání scény z aplikace.
`SceneDidEnterBackground`	`UIKit.UIScene`	Vyvolá se, když je scéna spuštěná na pozadí a není na obrazovce.
`SceneDidFailToContinueUserActivity`	`UIKit.UIScene`, , `stringFoundation.NSError`	Vyvoláno, aby uživatele informovalo, že aktivitu nebylo možné dokončit.
`SceneDidUpdateUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Vyvoláno při aktualizaci zadané aktivity.
`SceneOnActivated`	`UIKit.UIScene`	Vyvoláno, když se scéna stane aktivní a dokáže reagovat na události uživatelů.
`SceneOnResignActivation`	`UIKit.UIScene`	Vyvolá se, když se scéna chystá rezignovat aktivní stav a přestat reagovat na události uživatele.
`SceneOpenUrl`	`UIKit.UIScene`, `Foundation.NSSet<UIKit.UIOpenUrlContext>`	Vyvolá se, když scéna požádá o otevření jedné nebo více adres URL.
`SceneRestoreInteractionState`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Vyvoláno k obnovení stavu aktivity.
`SceneWillConnect`	`UIKit.UIScene`, , `UIKit.UISceneSessionUIKit.UISceneConnectionOptions`	Vyvoláno při přidání scény do aplikace.
`SceneWillContinueUserActivity`	`UIKit.UIScene`, `string`	Vyvolána k přípravě na příjem dat souvisejících s předáním.
`SceneWillEnterForeground`	`UIKit.UIScene`	Vyvolá se, když se scéna chystá spustit v popředí a stane se viditelným pro uživatele.
`WillEnterForeground`	`UIKit.UIApplication`	Vyvoláno, pokud se aplikace vrátí ze stavu na pozadí.
`WillFinishLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Vyvoláno při spuštění aplikace, ale obnovení stavu ještě nedošlo.
`WillTerminate`	`UIKit.UIApplication`	Vyvoláno, pokud je aplikace ukončena kvůli omezením paměti nebo přímo uživatelem.
`WindowSceneDidUpdateCoordinateSpace`	`UIKit.UIWindowScene`, `UIKit.IUICoordinateSpace`, , `UIKit.UIInterfaceOrientationUIKit.UITraitCollection`	Vyvolá se při změně velikosti, orientace nebo vlastností scény.

Důležité

Každý delegát, s výjimkou PerformFetch, má odpovídající identicky pojmenovanou rozšiřující metodu, kterou lze volat pro registraci obslužné rutiny pro delegáta.

Pokud chcete odpovědět na vyvolání delegáta životního cyklu iOS, zavolejte ConfigureLifecycleEvents metodu objektu MauiAppBuilder v CreateMauiapp metodě třídy MauiProgram . Pak v objektu ILifecycleBuilder zavolejte metodu AddiOS a určete Action , která registruje obslužné rutiny pro požadované delegáty:

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

Další informace o životním cyklu aplikace pro iOS najdete v tématu Správa životního cyklu aplikace na developer.apple.com.

Windows

Následující tabulka uvádí delegáty .NET MAUI, které jsou vyvolány v reakci na vyvolání událostí životního cyklu Windows:

Delegát	Argumenty	Popis
`OnActivated`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowActivatedEventArgs`	Vyvolá se při vyvolání události platformy Activated , pokud aplikace znovu nesčítá.
`OnClosed`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowEventArgs`	Vyvolána při vyvolání události platformy Closed .
`OnLaunched`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Vyvoláno Application.OnLaunched přepsáním rozhraní .NET MAUI po vytvoření a aktivaci nativního okna.
`OnLaunching`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Vyvoláno přepsáním rozhraní .NET MAUI Application.OnLaunched před vytvořením a aktivací nativního okna.
`OnPlatformMessage`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformMessageEventArgs`	Vyvoláno, když rozhraní .NET MAUI přijímá konkrétní nativní zprávy systému Windows.
`OnPlatformWindowSubclassed`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformWindowSubclassedEventArgs`	Vyvolá se rozhraním .NET MAUI při podtřídě okna Win32.
`OnResumed`	`Microsoft.UI.Xaml.Window`	Vyvolá se při vyvolání události platformy `Activated` , pokud aplikace obnovuje.
`OnVisibilityChanged`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowVisibilityChangedEventArgs`	Vyvolána při vyvolání události platformy VisibilityChanged .
`OnWindowCreated`	`Microsoft.UI.Xaml.Window`	Vyvoláno při vytvoření nativního okna pro různé platformy `Window`.

.NET MAUI zveřejňuje konkrétní nativní zprávy systému Windows jako událost životního cyklu s delegátem OnPlatformMessage . Objekt WindowsPlatformMessageEventArgs , který doprovází tohoto delegáta MessageId , zahrnuje vlastnost typu uint. Hodnotu této vlastnosti můžete prozkoumat a zjistit, která zpráva byla předána do okna aplikace. Další informace o zprávách systému Windows naleznete v tématu Zprávy systému Windows (Začínáme s Win32 a C++). Seznam konstant zpráv okna najdete v tématu Oznámení okna.

Důležité

Každý delegát má odpovídající identickou metodu rozšíření, kterou lze volat k registraci obslužné rutiny pro delegáta.

Chcete-li odpovědět na vyvolání delegáta životního cyklu Systému Windows, zavolejte ConfigureLifecycleEvents metodu MauiAppBuilder na objektu v CreateMauiApp metodě třídy MauiProgram . Pak v objektu ILifecycleBuilder zavolejte metodu AddWindows a určete Action , která registruje obslužné rutiny pro požadované delegáty:

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

Načtení objektu Window

Kód platformy může načíst objekt aplikace Window z událostí životního cyklu platformy pomocí GetWindow metody rozšíření:

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

Vlastní události životního cyklu

I když .NET MAUI definuje delegáty, které jsou vyvolány v reakci na události životního cyklu platformy, zveřejňuje pouze společnou sadu událostí životního cyklu platformy. Zahrnuje ale také mechanismus, který obvykle pro autory knihoven umožňuje dostávat oznámení aplikacím při vyvolání dalších událostí životního cyklu platformy. Proces, jak toho dosáhnout, je následující:

Zaregistrujte obslužnou rutinu události pro událost životního cyklu platformy, která není vystavená rozhraním .NET MAUI.
V obslužné rutině události životního cyklu platformy načtěte ILifecycleEventService instanci a zavolejte její InvokeEvents metodu a zadejte název události platformy jako jeho argument.

Aplikace, které chtějí dostávat oznámení o události životního cyklu platformy, by pak měly upravit CreateMauiApp metodu své MauiProgram třídy tak, aby volala metodu ConfigureLifecycleEvents objektu MauiAppBuilder . Pak v objektu ILifecycleBuilder zavolejte metodu AddEvent a zadejte název události platformy a Action který se vyvolá při vyvolání události platformy.

Příklad

K události WinUI 3 Window.SizeChanged dojde, když se poprvé vykreslí okno nativní aplikace nebo změní jeho velikost vykreslování. .NET MAUI tuto událost platformy nezpřístupňuje jako událost životního cyklu. Aplikace ale můžou dostávat oznámení při vyvolání této události platformy pomocí následujícího přístupu:

Zaregistrujte obslužnou rutinu Window.SizeChanged události pro událost životního cyklu platformy:

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

V obslužné rutině události životního cyklu platformy načtěte ILifecycleEventService instanci a zavolejte její InvokeEvents metodu a zadejte název události platformy jako argument:
```
using Microsoft.Maui.LifecycleEvents;
...

#if WINDOWS
        static void OnSizeChanged(object sender, Microsoft.UI.Xaml.WindowSizeChangedEventArgs args)
        {
            ILifecycleEventService service = MauiWinUIApplication.Current.Services.GetRequiredService<ILifecycleEventService>();
            service.InvokeEvents(nameof(Microsoft.UI.Xaml.Window.SizeChanged));
        }
#endif
```
Typ MauiWinUIApplication ve Windows lze použít pro přístup k instanci nativní aplikace prostřednictvím jeho Current vlastnosti. Typ MauiApplication v Androidu se dá použít pro přístup k instanci nativní aplikace. MauiUIApplicationDelegate Podobně lze typ v iOSu použít pro přístup k instanci nativní aplikace.

Upozorňující

Vyvolání neregistrované události s InvokeEvents metodou nevyvolá výjimku.

CreateMauiApp V metodě třídy MauiProgram zavolejte ConfigureLifecycleEvents metodu objektuMauiAppBuilder. Pak v objektu ILifecycleBuilder zavolejte metodu AddEvent a zadejte název události platformy a Action který se vyvolá při vyvolání události platformy:

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

Celkovým účinkem je, že když uživatel změní velikost okna aplikace ve Windows, provede se akce zadaná v AddEvent metodě.

Poznámka:

Metoda AddEvent má také přetížení, které umožňuje zadat delegáta.

Share via

Životní cyklus aplikace

Události životního cyklu napříč platformami

Události životního cyklu platformy

Android

iOS

Windows

Načtení objektu Window

Vlastní události životního cyklu

Příklad

Váš názor

Další materiály