Desarrollo de Windows 10: ciclo de vida
Históricamente, Windows tiene un entorno en el que los usuarios pueden ejecutar varias aplicaciones simultáneamente. El usuario puede cambiar fácilmente entre diferentes aplicaciones. Este modelo no funciona bien para dispositivos de teléfono o tableta en los que el uso suele centrarse en una sola aplicación.
Uno de los desafíos más importantes a los que se enfrentan los programadores de aplicaciones de la Tienda Windows 8 será administrar y comprender el ciclo de vida de las aplicaciones. Si ha estado creando aplicaciones de Windows Phone, gran parte de esto le resultará familiar.
En Windows 8, el sistema operativo administra la vida útil de una aplicación y, aunque el usuario puede terminar una aplicación, normalmente el usuario abre nuevas aplicaciones sin terminar conscientemente las aplicaciones en ejecución.
La Plataforma universal de Windows (UWP) para Windows 10 aborda estos problemas, ofreciendo algunas cosas interesantes a los usuarios de escritorio para que múltiples aplicaciones puedan ejecutarse con una experiencia de múltiples ventanas.
Las aplicaciones de Windows pueden existir en tres estados en el nivel básico como se muestra a continuación.
Running
Suspended
Terminate
Cuando un usuario inicia / activa cualquier aplicación, entra en el running estado.
Las aplicaciones pueden suspenderse si un usuario no las usa y ya no está en primer plano.
Desde el estado Suspendido, las aplicaciones pueden reanudar esa aplicación o terminar el sistema operativo para recuperar los recursos del sistema.
Transición del estado del proceso
Es importante comprender las transiciones de estado del proceso en una aplicación en ejecución. Cuando el usuario inicia la aplicación por primera vez, se muestra la pantalla de inicio y luego la aplicación comienza a ejecutarse.
El proceso se puede explicar de la siguiente manera:
Cuando la aplicación se suspende, su aplicación tiene cinco segundos para manejar ese evento suspendido.
Cuando se suspende la aplicación, no se ejecuta absolutamente ningún código y no se asignan recursos.
Cuando se reanuda, se notifica a la aplicación que se ha reanudado. Si viene de un estado suspendido, no debe realizar ninguna acción.
Bajo presión de la memoria, es posible que su aplicación finalice.
Recuerde que no se le notificará en ese momento, por lo que cualquier guardado que realice deberá hacerlo cuando entre en el estado de aplicación suspendida.
Cuando la aplicación transita de un lado a otro entre Running y Suspended estados, eventos de suspensión y reanudación de incendios respectivamente.
A veces, necesita guardar datos. Luego, debe llamar a métodos asincrónicos como se muestra a continuación.
Application.Current.Suspending += new SuspendingEventHandler(App_Suspending);
async void App_Suspending(Object sender, Windows.ApplicationModel.SuspendingEventArgs e){
// Create a simple setting
localSettings.Values["FirstName"] = fName.Text;
localSettings.Values["LastName"] = lName.Text;
localSettings.Values["Email"] = email.Text;
}Application.Current.Resuming += new EventHandler<Object>(App_Resuming);
private void App_Resuming(Object sender, Object e){
fName.Text = localSettings.Values["FirstName"];
lName.Text = localSettings.Values["LastName"];
email.Text = localSettings.Values["Email"];
}Estudiemos un ejemplo en el que se agregan controles como se muestra en el archivo XAML dado a continuación.
<Page
x:Class = "UWPLifeCycleDemo.MainPage"
xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local = "using:UWPLifeCycleDemo"
xmlns:d = "http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable = "d">
<Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}">
<Hub Header = "Details" />
<StackPanel VerticalAlignment = "Top" HorizontalAlignment = "Left"
Margin = "12,64,0,0">
<TextBox Header = "First Name" Text = "{Binding FirstName,
Mode = TwoWay, UpdateSourceTrigger = PropertyChanged}"
Width = "200" />
<TextBox Header = "Last Name" Text = "{Binding LastName, Mode = TwoWay,
UpdateSourceTrigger = PropertyChanged}" Width = "200" />
<TextBox Header = "Email" Text = "{Binding Email, Mode = TwoWay,
UpdateSourceTrigger = PropertyChanged}" Width = "200" />
<Button Margin = "0,12">Submit</Button>
</StackPanel>
</Grid>
</Page>A continuación se muestra el código C # en el que se implementan los eventos Suspend y Resume. Los datos actuales se almacenarán en elsuspend event en la configuración local y luego los datos se recuperarán en el resume event desde la configuración local como se muestra a continuación.
using System;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
namespace UWPLifeCycleDemo {
/// <summary>
/// An empty page that can be used on its own or navigated to within a Frame.
/// </summary>
public sealed partial class MainPage : Page{
var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
public MainPage() {
this.InitializeComponent();
Application.Current.Suspending += new SuspendingEventHandler(App_Suspending);
Application.Current.Resuming += new EventHandler<Object>(App_Resuming);
}
async void App_Suspending(Object sender, Windows.ApplicationModel.SuspendingEventArgs e){
// Create a simple setting
localSettings.Values["FirstName"] = fName.Text;
localSettings.Values["LastName"] = lName.Text;
localSettings.Values["Email"] = email.Text;
}
private void App_Resuming(Object sender, Object e){
fName.Text = localSettings.Values["FirstName"];
lName.Text = localSettings.Values["LastName"];
email.Text = localSettings.Values["Email"];
}
}
public abstract class BindableBase : INotifyPropertyChanged {
private string _FirstName = default(string);
public string FirstName {
get { return _FirstName; }
set { Set(ref _FirstName, value); }
}
private string _LastName = default(string);
public string LastName {
get { return _LastName; }
set { Set(ref _LastName, value); }
}
private string _Email = default(string);
public string Email {
get { return _Email; }
set { Set(ref _Email, value); }
}
public event PropertyChangedEventHandler PropertyChanged;
public void RaisePropertyChanged([CallerMemberName]string propertyName = null) {
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
public void Set<T>(ref T storage, T value,
[CallerMemberName()]string propertyName = null){
if (!object.Equals(storage, value)){
storage = value;
RaisePropertyChanged(propertyName);
}
}
}
}Cuando se compile y ejecute el código anterior, verá la siguiente ventana. Ahora escriba la información deseada.
Vamos a la Lifecycle Menú desplegable de eventos y seleccione suspended. Ahora su aplicación se suspenderá y la información deseada se almacenará en la configuración local. Vea la captura de pantalla que se muestra a continuación.
Ahora, cuando desee reanudar su aplicación, seleccione la opción Resume desde el Lifecycle Events menú.
Ahora verá que la información almacenada se recupera de la configuración local y la aplicación se reanuda en el mismo estado desde el que se suspendió.
