Ciclo de vida de la aplicación

Article
10/31/2024

Las aplicaciones .NET Multi-platform App UI (.NET MAUI) suelen tener cuatro estados de ejecución: not running, running, deactivated y stopped. .NET MAUI genera eventos de ciclo de vida multiplataforma en la clase Window cuando una aplicación pasa del estado de no en ejecución al estado en ejecución, del estado en ejecución al estado desactivado, del estado desactivado al estado detenido, del estado detenido al estado en ejecución y del estado detenido al estado no en ejecución.

El siguiente diagrama muestra una vista general del ciclo de vida de la aplicación .NET MAUI:

Ciclo de vida de la aplicación .NET MAUI

En el diagrama, el óvalo gris indica que la aplicación no se carga en la memoria. Los óvalos azules claros indican que la aplicación está en la memoria. El texto de los arcos indica los eventos que genera .NET MAUI, que proporcionan notificaciones a la aplicación en ejecución.

El estado de ejecución de una aplicación depende del historial de la aplicación. Por ejemplo, cuando se instala una aplicación por primera vez o se inicia un dispositivo, la aplicación se puede considerar que no está en ejecución. Cuando se inicia la aplicación, se generan los eventos Created y Activated y la aplicación está en ejecución. Si otra ventana de aplicación obtiene el foco, se genera el evento Deactivated y la aplicación está desactivada. Si el usuario cambia a otra aplicación o vuelve a la pantalla de inicio del dispositivo, de modo que la ventana de la aplicación deja de estar visible, se generan los eventos Deactivated y Stopped y la aplicación está detenida. Si el usuario vuelve a la aplicación, se genera el evento Resuming y la aplicación está en ejecución. Como alternativa, un usuario podría finalizar una aplicación mientras se ejecuta. En esta situación, la aplicación se desactiva luego se detiene, se genera el evento Destroying y la aplicación no está en ejecución. Del mismo modo, un dispositivo podría finalizar una aplicación mientras se detiene, debido a restricciones de recursos y se genera el evento Destroying y la aplicación no está en ejecución.

Además, .NET MAUI permite a las aplicaciones recibir notificaciones cuando se generan eventos de ciclo de vida de la plataforma. Para obtener más información, consulta Eventos del ciclo de vida de la plataforma.

Eventos de ciclo de vida multiplataforma

La clase Window define los siguientes eventos de ciclo de vida multiplataforma:

Evento	Descripción	Acción que realizar
`Created`	Este evento se genera después de crear la ventana nativa. En este momento, la ventana multiplataforma tendrá un controlador de ventana nativo, pero es posible que la ventana aún no esté visible.
`Activated`	Este evento se genera cuando se ha activado la ventana y es, o se convertirá en, la ventana centrada.
`Deactivated`	Este evento se genera cuando la ventana ya no es la ventana activa. Pero es posible que la ventana siga siendo visible.
`Stopped`	Este evento se genera cuando la ventana ya no está visible. No hay ninguna garantía de que una aplicación se reanude desde este estado, ya que el sistema operativo puede finalizarlo.	Desconéctate de los procesos de larga duración o cancela las solicitudes pendientes que puedan consumir recursos del dispositivo.
`Resumed`	Este evento se genera cuando una aplicación se reanuda después de detenerse. Este evento no se generará la primera vez que se inicie la aplicación y solo se puede generar si el evento `Stopped` se ha generado anteriormente.	Suscríbete a los eventos necesarios y actualiza cualquier contenido que esté en la página visible.
`Destroying`	Este evento se genera cuando se destruye y desasigna la ventana nativa. Es posible que se use la misma ventana multiplataforma en una nueva ventana nativa cuando se vuelva a abrir la aplicación.	Quita las suscripciones de eventos que hayas asociado a la ventana nativa.

Estos eventos multiplataforma se asignan a diferentes eventos de plataforma y en la tabla siguiente se muestra esta asignación:

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

Además, la clase Window también define un evento Backgrounding que se genera en iOS y Mac Catalyst cuando la ventana está cerrada o entra en un estado en segundo plano. Un objeto BackgroundingEventArgs acompaña a este evento y cualquier estado string debe conservarse en la propiedad State del objeto BackgroundingEventArgs, que el sistema operativo conservará hasta que sea el momento de reanudar la ventana. Cuando se reanuda la ventana, el argumento IActivationState proporciona el estado a la invalidación CreateWindow.

Además de estos eventos, la clase Window tiene los siguientes métodos de ciclo de vida reemplazables:

OnCreated, que se invoca cuando se genera el evento Created.
OnActivated, que se invoca cuando se genera el evento Activated.
OnDeactivated, que se invoca cuando se genera el evento Deactivated.
OnStopped, que se invoca cuando se genera el evento Stopped.
OnResumed, que se invoca cuando se genera el evento Resumed.
OnDestroying, que se invoca cuando se genera el evento Destroying.
OnBackgrounding, que se invoca cuando se genera el evento Backgrounding.

Para suscribirte a los eventos Window de ciclo de vida, invalida el método CreateWindow de la clase App para crear una instancia de Window en la que puedas suscribirte a eventos:

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

Como alternativa, para consumir las invalidaciones del ciclo de vida, crea una clase que derive de la clase Window.

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

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

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

Después, la clase derivada de Window se puede consumir invalidando el método CreateWindow de la clase App para devolver una instancia MyWindow.

Advertencia

Se producirá InvalidOperationException si se establece la propiedad App.MainPage y el método CreateWindow crea un objeto Window mediante la invalidación que acepta un argumento Page.

Eventos de ciclo de vida de la plataforma

.NET MAUI define delegados que se invocan en respuesta a los eventos de ciclo de vida de la plataforma que se generan. Los controladores se pueden especificar para estos delegados, mediante métodos con nombre o funciones anónimas, que se ejecutan cuando se invoca al delegado. Este mecanismo permite a las aplicaciones recibir notificaciones cuando se generan eventos comunes del ciclo de vida de la plataforma.

Importante

El método ConfigureLifecycleEvents está en el espacio de nombres Microsoft.Maui.LifecycleEvents.

Android

En la tabla siguiente se enumeran los delegados .NET MAUI que se invocan en respuesta a los eventos de ciclo de vida de Android que se generan:

Delegar	Argumentos	Descripción	Comentarios
`OnActivityResult`	`Android.App.Activity`, `int`, `Android.App.Result`, `Android.Content.Intent?`	Se invoca cuando se cierra una actividad iniciada.
`OnApplicationConfigurationChanged`	`Android.App.Application`, `Android.Content.Res.Configuration`	Se invoca cuando cambia la configuración del dispositivo mientras se ejecuta el componente.
`OnApplicationCreate`	`Android.App.Application`	Se invoca cuando se ha iniciado la aplicación, antes de que se hayan creado objetos de actividad, servicio o receptor (excepto proveedores de contenido).
`OnApplicationCreating`	`Android.App.Application`	Se invoca cuando se inicia la aplicación, antes de que se hayan creado objetos de actividad, servicio o receptor (excepto los proveedores de contenido).
`OnApplicationLowMemory`	`Android.App.Application`	Se invoca cuando el sistema se está ejecutando poco en la memoria y los procesos que se ejecutan activamente deben recortar su uso de memoria.
`OnApplicationTrimMemory`	`Android.App.Application`, `Android.Content.TrimMemory`	Se invoca cuando el sistema operativo ha determinado que es un buen momento para que un proceso recorte la memoria innecesaria de su proceso.
`OnBackPressed`	`Android.App.Activity`	Se invoca cuando la actividad ha detectado una pulsación de la tecla Atrás.
`OnConfigurationChanged`	`Android.App.Activity`, `Android.Content.Res.Configuration`	Se invoca cuando cambia la configuración del dispositivo mientras se ejecuta la actividad.
`OnCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Se genera cuando se crea la actividad.
`OnDestroy`	`Android.App.Activity`	Se invoca cuando finaliza la actividad o porque el sistema destruye temporalmente la instancia de actividad para ahorrar espacio.	Llama siempre a la implementación de la superclase.
`OnNewIntent`	`Android.App.Activity`, `Android.Content.Intent?`	Se invoca cuando se reinicia la actividad mientras se encuentra en la parte superior de la pila de actividad en lugar de una nueva instancia de la actividad que se está iniciando.
`OnPause`	`Android.App.Activity`	Se invoca cuando una actividad entra en segundo plano, pero aún no se ha matado.	Llama siempre a la implementación de la superclase.
`OnPostCreate`	`Android.App.Activity`, `Android.OS.Bundle?`	Se invoca cuando se completa el inicio de la actividad, después de llamar a `OnStart` y `OnRestoreInstanceState`.	Llama siempre a la implementación de la superclase. Se trata de un evento exclusivo del sistema que, por lo general, las aplicaciones no deberían usar.
`OnPostResume`	`Android.App.Activity`	Se invoca cuando se completa la reanudación de actividad, después de llamar a `OnResume`.	Llama siempre a la implementación de la superclase. Se trata de un evento exclusivo del sistema que, por lo general, las aplicaciones no deberían usar.
`OnRequestPermissionsResult`	`Android.App.Activity`, `int`, `string[]`, `Android.Content.PM.Permission[]`	Se invoca como devolución de llamada para el resultado de solicitud permisos.
`OnRestart`	`Android.App.Activity`	Se invoca después de `OnStop` cuando se vuelve a reproducir la actividad actual al usuario (el usuario ha vuelto a ir a ella).	Llama siempre a la implementación de la superclase.
`OnRestoreInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Se invoca después de `OnStart` cuando se reinicializa la actividad desde un estado guardado anteriormente.
`OnResume`	`Android.App.Activity`	Se invoca después de `OnRestoreInstanceState`, `OnRestart` o `OnPause`, para indicar que la actividad está activa y está lista para recibir entradas.
`OnSaveInstanceState`	`Android.App.Activity`, `Android.OS.Bundle`	Se invoca para recuperar el estado por instancia de una actividad que se elimina para que el estado se pueda restaurar en `OnCreate` o `OnRestoreInstanceState`.
`OnStart`	`Android.App.Activity`	Se invoca después de `OnCreate` o `OnRestart` cuando se ha detenido la actividad, pero ahora se muestra al usuario.	Llama siempre a la implementación de la superclase.
`OnStop`	`Android.App.Activity`	Se invoca cuando la actividad ya no es visible para el usuario.	Llama siempre a la implementación de la superclase.

Importante

Cada delegado tiene un método de extensión con nombre idéntico correspondiente, al que se puede llamar para registrar un controlador para el delegado.

Para responder a la invocación de un delegado de ciclo de vida de Android, llama al método ConfigureLifecycleEvents en el objeto MauiAppBuilder del método MauiProgram de la clase CreateMauiapp. Después, en el objeto ILifecycleBuilder, llama al método AddAndroid y especifica el elemento Action que registra controladores para los delegados necesarios:

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

Para obtener más información sobre el ciclo de vida de la aplicación Android, consulta Cómo interpretar el ciclo de vida de una actividad en developer.android.com.

iOS y Mac Catalyst

En la siguiente tabla se enumeran los delegados de .NET MAUI que se invocan en respuesta a los eventos de ciclo de vida de iOS y Mac Catalyst que se generan:

Delegar	Argumentos	Descripción
`ApplicationSignificantTimeChange`	`UIKit.UIApplication`	Se invoca cuando se produce un cambio de hora significativo, como la medianoche, el cambio de hora del operador o el inicio o fin del horario de verano.
`ContinueUserActivity`	`UIKit.UIApplication`, `Foundation.NSUserActivity`, `UIKit.UIApplicationRestorationHandler`	Se invoca cuando la aplicación recibe datos asociados a una actividad de usuario, como transferir una actividad de otro dispositivo mediante Handoff.
`DidEnterBackground`	`UIKit.UIApplication`	Se invoca cuando la aplicación ha entrado en segundo plano.
`FinishedLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Se invoca cuando se ha iniciado la aplicación.
`OnActivated`	`UIKit.UIApplication`	Se invoca cuando se inicia la aplicación y cada vez que la aplicación vuelve al primer plano.
`OnResignActivation`	`UIKit.UIApplication`	Se invoca cuando la aplicación está a punto de pasar a segundo plano, suspenderse o cuando el usuario recibe una interrupción, como una llamada telefónica o un mensaje de texto.
`OpenUrl`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Se invoca cuando la aplicación debe abrir una dirección URL especificada.
`PerformActionForShortcutItem`	`UIKit.UIApplication`, `UIKit.UIApplicationShortcutItem`, `UIKit.UIOperationHandler`	Se invoca cuando se inicia una acción rápida de la pantalla de inicio.
`PerformFetch`	`UIKit.UIApplication`, `Action<UIBackgroundFetchResult>`	Se invoca para indicar a la aplicación que puede iniciar una operación de captura si tiene datos que descargar.
`SceneContinueUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Se invoca para controlar la actividad relacionada con Handoff especificada.
`SceneDidDisconnect`	`UIKit.UIScene`	Se invoca cuando se quita una escena de la aplicación.
`SceneDidEnterBackground`	`UIKit.UIScene`	Se invoca cuando una escena se ejecuta en segundo plano y no está en pantalla.
`SceneDidFailToContinueUserActivity`	`UIKit.UIScene`, `string`, `Foundation.NSError`	Se invoca para informar al usuario de que no se pudo completar la actividad.
`SceneDidUpdateUserActivity`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Se invoca cuando se actualiza la actividad especificada.
`SceneOnActivated`	`UIKit.UIScene`	Se invoca cuando la escena se activa y puede responder a eventos de usuario.
`SceneOnResignActivation`	`UIKit.UIScene`	Se invoca cuando la escena está a punto de renunciar al estado activo y dejar de responder a eventos de usuario.
`SceneOpenUrl`	`UIKit.UIScene`, `Foundation.NSSet<UIKit.UIOpenUrlContext>`	Se invoca cuando una escena pide abrir una o varias direcciones URL.
`SceneRestoreInteractionState`	`UIKit.UIScene`, `Foundation.NSUserActivity`	Se invoca para restaurar el estado de la actividad.
`SceneWillConnect`	`UIKit.UIScene`, `UIKit.UISceneSession`, `UIKit.UISceneConnectionOptions`	Se invoca cuando se agrega una escena a la aplicación.
`SceneWillContinueUserActivity`	`UIKit.UIScene`, `string`	Se invoca para preparar la recepción de datos relacionados con Handoff.
`SceneWillEnterForeground`	`UIKit.UIScene`	Se invoca cuando una escena está a punto de ejecutarse en primer plano y se vuelve visible para el usuario.
`WillEnterForeground`	`UIKit.UIApplication`	Se invoca si la aplicación va a volver de un estado en segundo plano.
`WillFinishLaunching`	`UIKit.UIApplication`, `Foundation.NSDictionary`	Se invoca cuando se ha iniciado el lanzamiento de la aplicación, pero aún no se ha producido la restauración del estado.
`WillTerminate`	`UIKit.UIApplication`	Se invoca si la aplicación finaliza debido a restricciones de memoria o directamente por el usuario.
`WindowSceneDidUpdateCoordinateSpace`	`UIKit.UIWindowScene`, `UIKit.IUICoordinateSpace`, `UIKit.UIInterfaceOrientation`, `UIKit.UITraitCollection`	Se invoca cuando cambia el tamaño, la orientación o los rasgos de una escena.

Importante

Cada delegado, con la excepción de PerformFetch, tiene un método de extensión con el mismo nombre correspondiente al que se puede llamar para registrar un controlador para el delegado.

Para responder a un delegado de ciclo de vida de iOS y Mac Catalyst que se invoca, llame al método ConfigureLifecycleEvents en el objeto MauiAppBuilder del método CreateMauiapp de la clase MauiProgram. Después, en el objeto ILifecycleBuilder, llama al método AddiOS y especifica el elemento Action que registra controladores para los delegados necesarios:

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

Para obtener más información sobre el ciclo de vida de la aplicación de iOS, consulta Managing Your App's Life Cycle en developer.apple.com.

Windows

En la tabla siguiente se enumeran los delegados de .NET MAUI que se invocan en respuesta a los eventos de ciclo de vida de Windows que se generan:

Delegar	Argumentos	Descripción
`OnActivated`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowActivatedEventArgs`	Se invoca cuando se genera el evento Activated de la plataforma, si la aplicación no se reanuda.
`OnClosed`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowEventArgs`	Se invoca cuando se genera el evento Closed de la plataforma.
`OnLaunched`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Lo invoca la invalidación Application.OnLaunched de .NET MAUI una vez creada y activada la ventana nativa.
`OnLaunching`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.LaunchActivatedEventArgs`	Lo invoca la invalidación Application.OnLaunched de .NET MAUI antes de que se haya creado y activado la ventana nativa.
`OnPlatformMessage`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformMessageEventArgs`	Se invoca cuando .NET MAUI recibe mensajes nativos específicos de Windows.
`OnPlatformWindowSubclassed`	`Microsoft.UI.Xaml.Window`, `WindowsPlatformWindowSubclassedEventArgs`	Lo invoca .NET MAUI cuando la ventana Win32 tiene subclases.
`OnResumed`	`Microsoft.UI.Xaml.Window`	Se invoca cuando se genera el evento `Activated` de la plataforma, si la aplicación se reanuda.
`OnVisibilityChanged`	`Microsoft.UI.Xaml.Window`, `Microsoft.UI.Xaml.WindowVisibilityChangedEventArgs`	Se invoca cuando se genera el evento VisibilityChanged de la plataforma.
`OnWindowCreated`	`Microsoft.UI.Xaml.Window`	Se invoca cuando se crea la ventana nativa para `Window` multiplataforma.

.NET MAUI expone mensajes nativos específicos de Windows como un evento de ciclo de vida con el delegado OnPlatformMessage. El objeto WindowsPlatformMessageEventArgs que acompaña a este delegado incluye una propiedad MessageId de tipo uint. El valor de esta propiedad se puede examinar para determinar qué mensaje se ha pasado a la ventana de tu aplicación. Para obtener más información sobre los mensajes de Windows, consulta Mensajes de Windows (Introducción a Win32 y C++). Para obtener una lista de constantes de mensajes de ventana, consulta Notificaciones de ventana.

Importante

Cada delegado tiene un método de extensión con nombre idéntico correspondiente, al que se puede llamar para registrar un controlador para el delegado.

Para responder a la invocación de un delegado de ciclo de vida de Windows, llama al método ConfigureLifecycleEvents en el objeto MauiAppBuilder del método CreateMauiApp de tu clase MauiProgram. Después, en el objeto ILifecycleBuilder, llama al método AddWindows y especifica el elemento Action que registra controladores para los delegados necesarios:

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

Recuperar el objeto Window

El código de la plataforma puede recuperar el objeto Window de la aplicación de los eventos del ciclo de vida de la plataforma, con el método de extensión GetWindow:

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

Eventos de ciclo de vida personalizados

Si bien .NET MAUI define delegados que se invocan en respuesta a eventos de ciclo de vida de la plataforma que se generan, solo expone un conjunto común de eventos de ciclo de vida de la plataforma. Pero también incluye un mecanismo, normalmente para los autores de bibliotecas, que permite a las aplicaciones recibir notificaciones cuando se generan eventos adicionales del ciclo de vida de la plataforma. El proceso para llevarlo a cabo es el siguiente:

Registra un controlador de eventos para un evento de ciclo de vida de la plataforma que .NET MAUI no exponga.
En el controlador de eventos para el evento de ciclo de vida de la plataforma, recupere la instancia ILifecycleEventService y llama a su método InvokeEvents, especificando el nombre del evento de la plataforma como argumento.

Después, las aplicaciones que quieran recibir la notificación del evento de ciclo de vida de la plataforma deben modificar el método CreateMauiApp de su clase MauiProgram para llamar al método ConfigureLifecycleEvents en el objeto MauiAppBuilder. Después, en el objeto ILifecycleBuilder, llama al método AddEvent y especifica el nombre del evento de la plataforma y el elemento Action que se invocará cuando se genere el evento de plataforma.

Ejemplo

El evento Window.SizeChanged de WinUI 3 se produce cuando la ventana de la aplicación nativa se ha representado por primera vez o ha cambiado su tamaño de representación. .NET MAUI no expone este evento de plataforma como un evento de ciclo de vida. Pero las aplicaciones pueden recibir notificaciones cuando se genera este evento de plataforma mediante el siguiente enfoque:

Registra un controlador de eventos para el evento de ciclo de vida de la plataforma Window.SizeChanged:

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

En el controlador de eventos para el evento de ciclo de vida de la plataforma, recupere la instancia ILifecycleEventService y llama a su método InvokeEvents, especificando el nombre del evento de la plataforma como su argumento:
```
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
```
El tipo MauiWinUIApplication en Windows se puede usar para acceder a la instancia de aplicación nativa a través de su propiedad Current. El tipo MauiApplication en Android se puede usar para acceder a la instancia de aplicación nativa. Del mismo modo, el tipo MauiUIApplicationDelegate en iOS se puede usar para acceder a la instancia de aplicación nativa.

Advertencia

Invocar un evento no registrado, con el método InvokeEvents, no genera una excepción.

En el método CreateMauiApp de la clase MauiProgram , llama al método ConfigureLifecycleEvents en el objeto MauiAppBuilder . Después en el objeto ILifecycleBuilder, llama al método AddEvent y especifica el nombre del evento de plataforma y el elemento Action que se invocará cuando se genere el evento de plataforma:

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

El efecto general es que cuando un usuario cambia el tamaño de la ventana de la aplicación en Windows, se ejecuta la acción especificada en el método AddEvent.

Nota:

El método AddEvent también tiene una sobrecarga que permite especificar un delegado.

Comparteix a través de

Ciclo de vida de la aplicación

Eventos de ciclo de vida multiplataforma

Eventos de ciclo de vida de la plataforma

Android

iOS y Mac Catalyst

Windows

Recuperar el objeto Window

Eventos de ciclo de vida personalizados

Ejemplo

Recursos addicionals