Desenvolvimento do Windows 10 - Ciclo de Vida

Historicamente, o Windows possui ambiente, onde os usuários podem executar vários aplicativos simultaneamente. O usuário pode alternar entre diferentes aplicativos facilmente. Este modelo não funciona bem para telefones ou tablets em que o uso é normalmente focado em um único aplicativo.

Um dos desafios mais significativos que os programadores de aplicativos da Windows 8 Store enfrentam será gerenciar e compreender o ciclo de vida do aplicativo. Se você estiver criando aplicativos do Windows phone, muito disso será familiar.

No Windows 8, o sistema operacional gerencia a vida útil de um aplicativo e, embora o usuário possa encerrar um aplicativo, normalmente o usuário abre novos aplicativos sem encerrar conscientemente os aplicativos em execução.
A Plataforma Universal do Windows (UWP) para Windows 10 aborda esses problemas, oferecendo algumas coisas interessantes para os usuários de desktop para que vários aplicativos possam ser executados com uma experiência de várias janelas.

Os aplicativos do Windows podem existir em três estados no nível básico, conforme mostrado abaixo.

Running
Suspended
Terminate

Quando um usuário inicia / ativa qualquer aplicativo, ele vai para o running Estado.
Os aplicativos podem ser suspensos se um usuário não os usar e se eles não estiverem mais em primeiro plano.
No estado Suspenso, os aplicativos podem retomar esse aplicativo ou encerrar o sistema operacional para recuperar os recursos do sistema.

Transição de estado do processo

É importante entender as transições de estado do processo em um aplicativo em execução. Quando o usuário inicia o aplicativo pela primeira vez, a tela inicial é exibida e, em seguida, o aplicativo começa a ser executado.

O processo pode ser explicado da seguinte forma -

Quando o aplicativo está sendo suspenso, ele tem cinco segundos para lidar com o evento suspenso.
Quando o aplicativo é suspenso, absolutamente nenhum código é executado e nenhum recurso é alocado.
Quando ele é reiniciado, o aplicativo é notificado de que foi reiniciado. Se você saiu de um estado suspenso, não precisa fazer nada.
Sob pressão de memória, é possível que seu aplicativo seja encerrado.
Lembre-se de que você não será notificado nesse ponto e, portanto, qualquer salvamento que fizer, terá que ser feito quando entrar no estado de aplicativo suspenso.

Quando o aplicativo vai e volta entre Running e Suspended estados, disparar eventos de suspensão e retomada, respectivamente.

Às vezes, você precisa salvar dados. Em seguida, você deve chamar métodos assíncronos, conforme mostrado abaixo.

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

Vamos estudar um exemplo no qual os controles são adicionados conforme mostrado no arquivo XAML fornecido a seguir.

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

Abaixo está o código C # no qual os eventos Suspend e Resume são implementados. Os dados atuais serão armazenados nosuspend event nas configurações locais e, em seguida, os dados serão recuperados no resume event nas configurações locais, conforme mostrado abaixo.

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

Quando o código acima for compilado e executado, você verá a seguinte janela. Agora escreva as informações desejadas.

Vamos para o Lifecycle Menu suspenso de eventos e selecione suspended. Agora seu aplicativo será suspenso e as informações desejadas serão armazenadas nas configurações locais. Veja a imagem abaixo.

Agora, quando quiser retomar sua inscrição, selecione a opção Resume de Lifecycle Events cardápio.

Agora você verá que as informações armazenadas são recuperadas das configurações locais e o aplicativo é retomado no mesmo estado em que foi suspenso.

↰ Previous page Next page ↱