Parte 2: Administrar el ciclo de vida y el estado de la aplicación (aplicaciones de la Tienda Windows con C#/VB y XAML)

Applies to Windows only

En Windows 8 puedes iniciar varias aplicaciones y cambiar entre ellas sin tener que preocuparte porque el sistema se ralentice o se agote la batería. Esto es porque el sistema suspende de forma automática (y a veces finaliza) las aplicaciones que se ejecutan en segundo plano. Si la aplicación está bien diseñada, el sistema puede suspenderla, finalizarla y volver a iniciarla como si hubiera estado funcionando todo el tiempo.

Importante  Este tutorial está diseñado para usarse con Microsoft Visual Studio 2013 y Windows 8.1. Algunas partes del tutorial no funcionarán correctamente con Microsoft Visual Studio 2012 y Windows 8.

En este tutorial aprenderás a:

  • Guardar estados usando diferentes tipos de almacenamiento
  • Restaurar el estado de las aplicaciones la próxima vez que se inicien

Antes de comenzar...

Sobre el ciclo de vida de la aplicación

Antes de que vuelvas al código, hablemos un poco sobre el ciclo de vida de la aplicación. La activación marca el comienzo del ciclo de vida de la aplicación. En cualquier momento dado, una aplicación no está en ejecución, está en ejecución o está suspendida.

Ciclo de vida de la aplicación

Se puede suspender una aplicación cuando el usuario cambia a otra aplicación o cuando Windows entra en modo de bajo consumo. Mientras la aplicación está suspendida, sigue residiendo en la memoria, por lo que los usuarios pueden cambiar entre aplicaciones suspendidas rápidamente y reanudarlas. Cuando se suspende y se vuelve a reanudar la aplicación, no tienes que escribir ningún otro código para hacer que parezca como que ha estado en ejecución todo el tiempo.

Pero Windows también puede finalizar una aplicación suspendida en cualquier momento para liberar memoria para otras aplicaciones o para ahorrar energía. Cuando finaliza tu aplicación, deja de ejecutarse y se descarga de la memoria.

Cuando el usuario cierra una aplicación presionando Alt+F4 o mediante el gesto de cierre, la aplicación se suspende durante 10 segundos y luego finaliza.

Windows notifica a la aplicación cuando la suspende, pero no ofrece ninguna otra notificación cuando la finaliza, lo que significa que tu aplicación debe controlar el evento de suspensión y usarlo para guardar su estado y liberar inmediatamente sus recursos exclusivos e identificadores de archivos.

Para crear una buena experiencia de usuario, quieres que parezca como si la aplicación no hubiera dejado nunca de ejecutarse. Esto quiere decir que la aplicación necesita mantener cualquier dato escrito por el usuario, configuración cambiada, etc. Así, tienes que guardar el estado de la aplicación cuando se suspende, por si Windows la finaliza, para poder restaurar su estado más adelante.

Existen dos tipos de datos que puedes administrar en la aplicación: datos de la aplicación y datos de sesión.

En los pasos siguientes, aprenderás a actualizar la aplicación para guardar estos tipos de datos. ¿Qué estado necesitas guardar? Ahora mismo, lo único que el usuario puede cambiar es la entrada de su nombre. El usuario también puede hacer clic en el botón Say "Hello" para generar un saludo personalizado.

Paso 1: Uso de SuspensionManager

En Parte 1: Crear una aplicación "Hello World", has reemplazado el archivo MainPage predeterminado por uno basado en la plantilla Página básica. Cuando usaste la plantilla Página básica, Microsoft Visual Studio agregó varios archivos al proyecto en la carpeta Common. Uno de estos archivos contiene la clase SuspensionManager. SuspensionManager es una clase auxiliar que simplifica la administración del ciclo de vida de la aplicación. Hace varias cosas por ti. Guarda y restaura el estado de navegación del Frame que hospeda las páginas de la aplicación. En una aplicación de una sola página, guardar el estado de navegación no parece muy importante, pero cobra relevancia cuando la aplicación tiene varias páginas. También le da a cada página la oportunidad de guardar y restaurar su estado. SuspensionManager serializa los datos del estado de la página y lo escribe en un archivo XML en el almacenamiento local de la aplicación.

Para usar la clase SuspensionManager en la aplicación, primero debes registrar el Frame de la aplicación principal. Cuando hayas terminado, SuspensionManager tendrá información de todas las páginas de la aplicación y podrá guardar y restaurar el estado de navegación. Registrarás el Frame inmediatamente después de crearlo en el método OnLaunched en App.xaml.cs/vb.

Hh986968.wedge(es-es,WIN.10).gifPara usar SuspensionManager

  1. Haz doble clic en App.xaml.cs/vb en el Explorador de soluciones para abrirlo.
  2. En el método OnLaunched, llama al método SuspensionManager.RegisterFrame para registrar el Frame raíz.
    
    HelloWorld.Common.SuspensionManager.RegisterFrame(rootFrame, "appFrame");
    
    

Agrega este código después de que se haya creado el nuevo Frame, como se muestra aquí.


            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();
                HelloWorld.Common.SuspensionManager.RegisterFrame(rootFrame, "appFrame");
            ...

Paso 2: Guardar el estado de la aplicación

Suele haber dos tipos de datos que puedes administrar en la aplicación: datos de la aplicación y datos de sesión. Los datos de la aplicación persisten durante las sesiones y siempre deben ser accesibles al usuario. En tu aplicación, el Text del TextBox nameInput son los datos de la aplicación. Guarda siempre los datos de la aplicación importantes de forma incremental durante la vida de la aplicación. Tu aplicación solo tiene cinco segundos para ejecutar código en el controlador de eventos de suspensión, por lo que tienes que asegurarte de que los datos importantes de la aplicación se guardan en almacenamiento persistente en el momento en que se suspende la aplicación.

Windows ofrece un objeto Windows.Storage.ApplicationData para ayudarte a administrar los datos de la aplicación. Este objeto tiene una propiedad RoamingSettings que devuelve un ApplicationDataContainer. Puedes usar este ApplicationDataContainer para almacenar los datos de la aplicación que persisten durante las sesiones. Guardemos el nombre de usuario en el ApplicationDataContainer de roaming mientras el usuario lo escribe.

Nota  Este tutorial muestra cómo usar RoamingSettings. El contenedor de datos de la aplicación de configuración de roaming facilita el almacenamiento de datos de manera accesible al usuario en varios equipos. Básicamente, los datos se cargan en la nube en segundo plano. También puedes usar el contenedor de datos de la aplicación de configuración local (LocalSettings), pero solo deberías usarlo cuando quieras almacenar información específica del equipo.

Guarda datos de la aplicación persistentes tan a menudo como sea necesario en tu aplicación. Aquí, controlas el evento TextBox.TextChanged y guardas el nombre de usuario en cuanto el usuario lo escribe.

Hh986968.wedge(es-es,WIN.10).gifPara guardar los datos de la aplicación

  1. Haz doble clic en MainPage.xaml en el Explorador de soluciones para abrirlo.
  2. En la vista de diseño o de lenguaje de marcado de aplicaciones extensible (XAML), selecciona el TextBox nameInput que agregaste a MainPage.xaml.
  3. En el panel Propiedades, haz clic en el botón Eventos (Botón de eventos).
  4. Busca el evento TextChanged en la lista de eventos. En el cuadro de texto del evento, escribe "NameInput_TextChanged" como el nombre de la función que controla el evento TextChanged.
  5. Presiona Entrar. El método de controlador de eventos se crea y se abre en un editor de código, de forma que puedes agregar código que se ejecutará cuando se produzca el evento.
  6. Agrega este código al controlador de eventos en la página de código subyacente. En el controlador de eventos, guardas el texto nameInput en roamingSettings.
    
    
                Windows.Storage.ApplicationDataContainer roamingSettings = 
                    Windows.Storage.ApplicationData.Current.RoamingSettings;
                roamingSettings.Values["userName"] = nameInput.Text;
    
    
  7. Presiona F5 para compilar y ejecutar la aplicación. Tu nombre se guardará según lo escribas en el cuadro de texto.

Los datos de la sesión son datos temporales relevantes para la sesión actual del usuario en tu aplicación. Una sesión finaliza cuando el usuario cierra la aplicación mediante el gesto de cierre o Alt + F4, reinicia el equipo o cierra sesión en el equipo. En tu aplicación, el Text del TextBlock greetingOutput son datos de sesión. Solo lo restauras si Windows suspende y finaliza la aplicación. Necesitas guardar el estado de navegación del Frame de la aplicación para que se pueda restaurar en la misma página en que estaba y así SuspensionManager sabrá de qué página debe restaurar el estado. También necesitas guardar el estado de la página misma. Aquí es donde guardas el texto de greetingOutput. Usas la clase SuspensionManager para guardar el estado de la sesión en el controlador de eventos Application.Suspending.

(Si quieres más información sobre otras formas de guardar el estado, consulta el tema sobre cómo administrar datos de la aplicación y cómo trabajar con el estado de forma eficiente).

El archivo App.xaml.cs/vb contiene un controlador para el evento Application.Suspending. Se llama a este controlador de eventos cuando Windows está a punto de suspender tu aplicación. Esta es tu oportunidad para guardar el estado de la aplicación en caso de que finalice. Usas la clase SuspensionManager para simplificar el guardado del estado de la sesión. Guarda el estado de navegación de la aplicación y te da la oportunidad de guardar el estado de la sesión de la página activa.

Hh986968.wedge(es-es,WIN.10).gifPara guardar el estado de la sesión

  1. Haz doble clic en App.xaml.cs/vb en el Explorador de soluciones para abrirlo.
  2. En App.xaml.cs/vb, agrega la palabra clave async a la firma del método OnSuspending.

    Si quieres más información sobre la programación asincrónica, consulta Inicio rápido: usar el operador await para la programación asincrónica.

  3. En el método OnSuspending, llama al método SuspensionManager.SaveAsync.
    
    
                await HelloWorld.Common.SuspensionManager.SaveAsync();
    
    
    

    La llamada a SaveAsync guarda el estado de navegación del Frame y luego da a la Page la oportunidad de guardar su contenido.

    Este es el método OnSuspending completo con las actualizaciones realizadas.

    
            /// <summary>
            /// Invoked when application execution is being suspended.  Application state is saved
            /// without knowing whether the application will be terminated or resumed with the contents
            /// of memory still intact.
            /// </summary>
            /// <param name="sender">The source of the suspend request.</param>
            /// <param name="e">Details about the suspend request.</param>
    
            private async void OnSuspending(object sender, SuspendingEventArgs e)
            {
                var deferral = e.SuspendingOperation.GetDeferral();
                //TODO: Save application state and stop any background activity
                await HelloWorld.Common.SuspensionManager.SaveAsync();
                deferral.Complete();
            }
    
    
  4. Haz doble clic en MainPage.xaml.cs/vb en el Explorador de soluciones para abrirlo.
  5. En MainPage.xaml.cs/vb, agrega código al método navigationHelper_SaveState para guardar el estado de la página.
    
    
                e.PageState["greetingOutputText"] = greetingOutput.Text;
    
    
    

    La clase SuspensionManager serializa y guarda el diccionario PageState en un archivo XML. Los datos guardados en PageState solo se guardan para esta sesión. Guardarás el texto del greetingOutput aquí.

    Este es el código completo para el método navigationHelper_SaveState.

    
    
    private void navigationHelper_SaveState(object sender, SaveStateEventArgs e)
    {
        e.PageState["greetingOutputText"] = greetingOutput.Text;
    }
    
    
  6. Haz clic en Compilar > Compilar solución para asegurarte de que la aplicación se compila sin errores.

Esto es todo lo que tienes que hacer para guardar el estado de la aplicación antes de que esta finalice. Ahora necesitas aprender a restaurar el estado de la aplicación la próxima vez que el usuario la inicie.

Paso 3: Restaurar el estado de la aplicación

Antes, viste que el archivo App.xaml.cs/vb contiene código que administra la activación de tu aplicación. Existen muchas formas diferentes de activar una aplicación. Aquí tratamos la activación de Launch y el método OnLaunched.

Una aplicación se inicia siempre que no estaba en ejecución y el usuario la activa. Cuando se inicia una aplicación, Windows muestra una pantalla de bienvenida para la aplicación.

Examinemos el código en App.xaml.cs/vb que controla la activación de la aplicación. El código define una invalidación del método OnLaunched. El código de este método se ejecuta solamente si la activación es de tipo Launch. (Puedes invalidar otros métodos para controlar otros tipos de activación, pero no lo tratamos aquí. Si quieres más información, consulta el tema sobre el ciclo de vida de la aplicación).

En primer lugar, el código declara un Frame e intenta asignarle el contenido de la ventana actual.


Frame rootFrame = Window.Current.Content as Frame;

Si la ventana ya contiene un Frame, indica que la aplicación ya se ha inicializado, de forma que se omite la inicialización de Frame.

Si la aplicación no se ha inicializado, el código crea un Frame para hospedar las páginas de la aplicación. Registrarás el Frame con SuspensionManager. Este es el código agregado en el paso 1.

Después, el código comprueba el estado de ejecución anterior para ver cómo se cerró la aplicación la última vez. Cuando el estado de ejecución anterior es Terminated, significa que la última vez que se ejecutó la aplicación, Windows la suspendió correctamente y luego la finalizó. En tal caso, tienes que restaurar el estado de la aplicación.


            // Do not repeat app initialization when the Window already has content,
            // just ensure that the window is active
            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();
                HelloWorld.Common.SuspensionManager.RegisterFrame(rootFrame, "appFrame");

                if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
                {
                    //TODO: Load state from previously suspended application
                }

                // Place the frame in the current Window
                Window.Current.Content = rootFrame;
            }


A continuación, el código comprueba si Frame tiene algún contenido. Si la aplicación ya se está ejecutando, o se restauró el estado de navegación, Frame ya tiene contenido. De lo contrario, Frame navega a la primera página de la aplicación. En este caso, navega a MainPage.


            if (rootFrame.Content == null)
            {
                // When the navigation stack isn't restored navigate to the first page,
                // configuring the new page by passing required information as a navigation
                // parameter
                if (!rootFrame.Navigate(typeof(MainPage), e.Arguments))
                {
                    throw new Exception("Failed to create initial page");
                }
            }


Por último, el código activa la ventana.



            // Ensure the current window is active
            Window.Current.Activate();


Ahora que sabes lo que ocurre cuando se inicia la aplicación, veamos cómo restaurar el estado de la misma.

Hh986968.wedge(es-es,WIN.10).gifPara restaurar el estado de la aplicación

  1. En App.xaml.cs/vb, agrega la palabra clave async a la firma del método OnLaunched.
    
    protected async override void OnLaunched(LaunchActivatedEventArgs e)
    
    
  2. Si finaliza la aplicación, llama al método SuspensionManager.RestoreAsync.

    La llamada a RestoreAsync restaura el estado de navegación del Frame y luego da a la Page la oportunidad de restaurar su contenido.

    
                if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
                {
                    //TODO: Load state from previously suspended application
                    await HelloWorld.Common.SuspensionManager.RestoreAsync();
                }
    
    
  3. En MainPage.xaml.cs/vb, agrega código al método navigationHelper_LoadState para restaurar el estado de la página.
    1. Primero comprueba si el diccionario de PageState existe y tiene una clave llamada greetingOutputText. Si la clave existe, utilízala para restaurar el texto de greetingOutput.
      
      
                  // Restore values stored in session state.
                  if (e.PageState != null && e.PageState.ContainsKey("greetingOutputText"))
                  {
                      greetingOutput.Text = e.PageState["greetingOutputText"].ToString();
                  }
      
      
      
    2. A continuación, carga el nombre de usuario. Como quieres que los datos del nombre de usuario persistan durante varias sesiones, lo almacenas en el contenedor de datos de la aplicación RoamingSettings. Vamos a agregar código para ver si el nombre de usuario existe y, en caso afirmativo, mostrarlo.
      
                  // Restore values stored in app data.
                  Windows.Storage.ApplicationDataContainer roamingSettings = 
                      Windows.Storage.ApplicationData.Current.RoamingSettings;
                  if (roamingSettings.Values.ContainsKey("userName"))
                  {
                      nameInput.Text = roamingSettings.Values["userName"].ToString();
                  }
      
      
      

    Este es el código completo para el método navigationHelper_LoadState.

    
    
            /// <summary>
            /// Populates the page with content passed during navigation.  Any saved state is also
            /// provided when recreating a page from a prior session.
            /// </summary>
            /// <param name="navigationParameter">The parameter value passed to
            /// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
            /// </param>
            /// <param name="pageState">A dictionary of state preserved by this page during an earlier
            /// session.  This will be null the first time a page is visited.</param>
            private void navigationHelper_LoadState(object sender, LoadStateEventArgs e)
            {
                // Restore values stored in session state.
                if (e.PageState != null && e.PageState.ContainsKey("greetingOutputText"))
                {
                    greetingOutput.Text = e.PageState["greetingOutputText"].ToString();
                }
    
    
                // Restore values stored in app data.
                Windows.Storage.ApplicationDataContainer roamingSettings =
                    Windows.Storage.ApplicationData.Current.RoamingSettings;
                if (roamingSettings.Values.ContainsKey("userName"))
                {
                    nameInput.Text = roamingSettings.Values["userName"].ToString();
                }
            }
    
    

Ahora puedes crear y ejecutar la aplicación, y ver cómo el estado de la sesión se guarda y se restaura. De momento, has probado la aplicación ejecutándola en modo de depuración y deteniéndola mediante la selección de Depurar > Detener depuración en Visual Studio. Pero esto hace que la aplicación realice un cierre normal y el evento Suspending no se produce. Afortunadamente, Visual Studio te deja simular la suspensión, finalización y restauración de una aplicación.

Hh986968.wedge(es-es,WIN.10).gifPara simular la suspensión, finalización y restauración de una aplicación en Visual Studio

  1. Presiona F5 para ejecutar la aplicación en modo de depuración.
  2. Escribe tu nombre en el cuadro de entrada y haz clic en "Say "Hello"" (Decir "Hola"). Se mostrará el saludo.
  3. Presiona Alt+Tab para regresar a Visual Studio.
  4. Abre el menú desplegable junto al botón Suspender en la barra de herramientas Ubicación de depuración.

    La barra de herramientas Ubicación de depuración aparece de manera predeterminada mientras se ejecuta el depurador. Si no la ves, haz clic en Ver > Barras de herramientas > Ubicación de depuración para mostrarla.

    Botón de suspensión y apagado

  5. Selecciona Suspend and shutdown (Suspender y cerrar).

    Visual Studio simula la suspensión y finalización de la aplicación, por lo que se produce el evento Suspending y se ejecuta el código de administración del estado.

  6. Presiona F5 para ejecutar la aplicación de nuevo. La aplicación se restaura a su estado anterior.
  7. Escribe tu nombre en el cuadro de texto y haz clic en "Say "Hello"" (Decir "Hola").
  8. Presiona Alt+Tab para regresar a Visual Studio.
  9. Cierra la aplicación. Para ello, selecciona Depurar > Detener depuración.
  10. Presiona F5 para ejecutar la aplicación de nuevo.

    Ahora, el nombre de usuario se restaura porque se guardó según lo escribías. El saludo no se restaura porque no se produjo el evento Suspending, así que el estado de la sesión no se guarda.

Resumen

Enhorabuena, ¡ya has acabado con el segundo tutorial! Has aprendido a guardar datos de la aplicación y el estado de la sesión en una aplicación de la Tienda Windows.

Consultar el código

¿Te has quedado atascado o quieres revisar tu trabajo? De ser así, consulta Código completo de la parte 2.

Pasos siguientes

En la siguiente parte de esta serie de tutoriales, aprenderás a usar las herramientas de diseño de Visual Studio para crear una interfaz de usuario más compleja. Ve a Parte 3: Navegación, diseño y vistas.

 

 

Mostrar:
© 2014 Microsoft