Sviluppo di Windows 10 - Ciclo di vita

Storicamente, Windows ha un ambiente in cui gli utenti possono eseguire più applicazioni contemporaneamente. L'utente può passare facilmente da un'applicazione all'altra. Questo modello non funziona bene per telefoni o tablet in cui l'utilizzo è tipicamente focalizzato su una singola applicazione.

Una delle sfide più significative che i programmatori di applicazioni di Windows 8 Store dovranno affrontare sarà la gestione e la comprensione del ciclo di vita dell'applicazione. Se hai creato applicazioni per Windows Phone, gran parte di questo ti sarà familiare.

  • In Windows 8, il sistema operativo gestisce la durata di un'applicazione e, sebbene l'utente possa terminare un'applicazione, in genere l'utente apre nuove applicazioni senza terminare consapevolmente le applicazioni in esecuzione.

  • La piattaforma UWP (Universal Windows Platform) per Windows 10 risolve questi problemi, offrendo alcune cose interessanti agli utenti desktop in modo che più applicazioni possano essere eseguite con un'esperienza con più finestre.

Le applicazioni Windows possono esistere in tre stati al livello di base come mostrato di seguito.

  • Running

  • Suspended

  • Terminate

  • Quando un utente avvia / attiva qualsiasi applicazione, entra nel file running stato.

  • Le applicazioni possono essere sospese se un utente non le utilizza e non è più in primo piano.

  • Dallo stato Sospeso, le applicazioni possono riprendere tale applicazione o terminare il sistema operativo per recuperare le risorse di sistema.

Transizione dello stato del processo

È importante comprendere le transizioni di stato del processo in un'applicazione in esecuzione. Quando l'utente avvia l'applicazione per la prima volta, viene visualizzata la schermata iniziale e quindi l'applicazione inizia a essere eseguita.

Il processo può essere spiegato come segue:

  • Quando l'applicazione è in sospensione, la tua app ha cinque secondi per gestire l'evento sospeso.

  • Quando l'applicazione viene sospesa, non viene eseguito assolutamente alcun codice e non vengono allocate risorse.

  • Quando riprende, l'app viene informata che è ripresa. Se provieni da uno stato di sospensione, non devi intraprendere alcuna azione.

  • Sotto pressione della memoria, è possibile che la tua applicazione venga terminata.

  • Ricorda che non sarai avvisato a quel punto, e quindi qualsiasi salvataggio che farai, lo dovrai fare quando entrerai nello stato dell'applicazione sospesa.

Quando l'applicazione transita avanti e indietro tra Running e Suspended stati, rispettivamente la sospensione del fuoco e la ripresa degli eventi.

A volte è necessario salvare i dati. Quindi devi chiamare metodi asincroni come mostrato di seguito.

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

Analizziamo un esempio in cui i controlli vengono aggiunti come mostrato nel file XAML fornito di seguito.

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

Di seguito è riportato il codice C # in cui vengono implementati gli eventi Suspend e Resume. I dati correnti verranno archiviati nel filesuspend event nelle impostazioni locali e quindi i dati verranno recuperati nel file resume event dalle impostazioni locali come mostrato di seguito.

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 il codice sopra è stato compilato ed eseguito, vedrai la seguente finestra. Ora scrivi le informazioni desiderate.

Andiamo al Lifecycle Menu a discesa Eventi e seleziona suspended. Ora la tua applicazione verrà sospesa e le informazioni desiderate verranno memorizzate nelle impostazioni locali. Vedere lo screenshot riportato di seguito.

Ora, quando vuoi riprendere la tua applicazione, seleziona l'opzione Resume dal Lifecycle Events menù.

Ora vedrai che le informazioni memorizzate vengono recuperate dalle impostazioni locali e l'applicazione viene ripresa nello stesso stato da cui era stata sospesa.