Modello di navigazione (con C#/VB/C++ e XAML)

  • Articolo

Il modello di navigazione usato nei modelli di progetto Applicazione hub, Applicazione griglia e Applicazione divisa è il modello di navigazione consigliato per le app di Windows Store in XAML. Questo modello crea un frame centrale come contenuto della finestra predefinita che gli utenti usano per passare ad altre pagine. Il modello di navigazione a frame singolo offre una transizione più uniforme e in stile app tra le pagine e rende inoltre più agevole gestire lo stato dei programmi. Per altre informazioni sulla navigazione e per un esempio di uso della navigazione predefinita in un'app di Windows Store scritta in XAML, vedi Guida introduttiva: Uso della navigazione a pagina singola.

Importante  Le informazioni contenute in questo argomento sono state aggiornate per Microsoft Visual Studio 2013.

Il file App.xaml.cs/vb/cpp crea un oggetto Frame, se non ne esiste già uno, e imposta Frame come contenuto della finestra corrente. Se il contenuto del frame è Null, l'app passa alla home page come specificato nel code-behind App.xaml. Ad esempio, nell'Applicazione griglia il codice è rootFrame.Navigate(typeof(GroupedItemsPage), "AllGroups") ).

Durante la configurazione, SuspensionManager registra l'oggetto Frame. SuspensionManager è una classe helper fornita nella cartella Comune del modello Applicazione griglia o Applicazione divisa che offre l'implementazione usata per archiviare e caricare lo stato quando l'app viene terminata.

Tutte le app passano da una fase all'altra del ciclo di vita di un'applicazione in base a quanto definito dal sistema operativo. Ogni volta che un'app viene terminata dal sistema, ad esempio a causa di vincoli delle risorse, di una chiusura, di un riavvio e così via, in qualità di sviluppatore dovrai ripristinare i dati non appena l'app riprenderà a funzionare. Per aiutarti a eseguire questa attività, viene fornito SuspensionManager.

SuspensionManager acquisisce lo stato della sessione globale per semplificare la gestione della durata dei processi di un'applicazione. Lo stato della sessione viene automaticamente cancellato in numerose circostanze e deve essere usato solo per ripristinare le informazioni che conviene trasmettere da una sessione all'altra, ma che devono essere ignorate quando un'applicazione viene arrestata in modo anomalo o aggiornata. Tali informazioni includono sostanzialmente i dati temporanei dell'interfaccia utente.

SuspensionManager include due proprietà: SessionState e KnownTypes.

  • SessionState consente l'accesso allo stato globale della sessione corrente. Tale stato viene serializzato dal metodo SaveAsync e ripristinato dal metodo RestoreAsync. Tutti i dati vengono salvati e ripristinati usando DataContractSerialization e devono essere il più possibile compatti. Le stringhe sono altri tipi di dati autonomi vivamente consigliati.
  • KnownTypes archivia un elenco di tipi personalizzati forniti a DataContractSerializer e usati dai metodi SaveAsync e RestoreAsync per la lettura e la scrittura dello stato di una sessione. Questa proprietà è inizialmente vuota ma è possibile aggiungervi altri tipi per personalizzare il processo di serializzazione.

SuspensionManager archivia lo stato in un dizionario denominato SessionState. Tale dizionario archivia FrameState in base a una chiave associata in modo univoco a un Frame. Ogni dizionario FrameState conserva lo stato di ogni pagina nello stato di navigazione per tale frame specifico. Ogni pagina archivia il parametro di navigazione e gli eventuali altri stati che l'utente decide di aggiungere.

Vediamone in dettaglio il funzionamento: quando viene creato un Frame, se vuoi che il relativo stato venga archiviato, devi registrarlo immediatamente. Per farlo, occorre effettuare la chiamata (SuspensionManager.RegisterFrame(rootFrame, "AppFrame")). A ogni frame deve essere associata una chiave univoca. In genere, la maggior parte delle app dispone di un singolo frame. Se dichiari un secondo frame, anche in questo caso dovrai registrarlo. Quando viene registrato un frame, vengono impostate due proprietà a esso associate. La prima è la chiave che hai associato al frame e la seconda è il dizionario dello stato della sessione che verrà associato al frame. La navigazione e lo stato dei frame precedentemente registrati verranno ripristinati immediatamente. È anche possibile annullare la registrazione dei frame. In questo caso, tutta la cronologia e lo stato di navigazione verranno cancellati.

Ecco invece i metodi per le chiamate importanti: SaveAsync e RestoreAsync. SaveAsync viene usato per salvare tutto il SessionState. Tutti i frame registrati tramite SuspensionManager.RegisterFrame conserveranno anche il rispettivo stack di navigazione corrente e potranno in questo modo salvare i dati della loro pagina attiva. SessionState viene quindi serializzato mediante un DataContractSerializer e scritto in un file archiviato nella cartella locale in base a quanto definito da ApplicationData.

Per leggere nel SessionState salvato in precedenza, viene usato il metodo RestoreAsync. Tutti i frame registrati tramite RegisterFrame ripristineranno anche il rispettivo stack di navigazione corrente e potranno in questo modo salvare lo stato della loro pagina attiva. Ancora una volta, come per SaveAsync, viene usato un DataContractSerializer per deserializzare lo stato archiviato in un file incluso nella cartella locale dell'applicazione.

Gli utenti osservano due errori comuni quando tentano di archiviare lo stato della loro app.

  • I tipi archiviati dalle singole pagine devono poter essere serializzati dal DataContractSerializer in C# e VB. A questo scopo, è innanzitutto necessario registrare tutti i tipi personalizzati per poterli salvare o ripristinare. SuspensionManager fornisce la raccolta KnownTypes che passa i propri tipi al DataContractSerializer. Poiché SuspensionManager viene chiamato per ripristinare lo stato nell'override del metodo OnLaunched del code-behind di App.xaml, una posizione consigliabile per registrare i tipi è rappresentata dal costruttore dell'app.

            public App()
        {
            this.InitializeComponent();
            this.Suspending += OnSuspending;
            SuspensionManager.KnownTypes.Add(typeof(MyCustomType));
        }

  • I parametri passati tramite navigazione devono poter essere serializzati dalla piattaforma. Quando salviamo e ripristiniamo lo stack di navigazione, chiamiamo Frame.GetNavigationState() e Frame.SetNavigationState(). Entrambe le chiamate usano un formato di serializzazione interno e tutti i tipi passati come parametro in Frame.Navigate() devono poter essere serializzati dalla piattaforma.

L'uso di SuspensionManager è incapsulato nell'implementazione di NavigationHelper.

NavigationHelper è un'implementazione di una pagina che offre i seguenti vantaggi importanti:

  • Gestori di eventi per GoBack, GoForward e GoHome.
  • Scelte rapide con il mouse e tasti di scelta rapida per la navigazione.
  • Gestione dello stato per la navigazione e gestione della durata dei processi.

Modello di visualizzazione predefinito

DefaultViewModel viene usato da ogni modello di elemento di pagina complessa. DataContext è associato al DefaultViewModel definito sulla pagina stessa:DataContext="{Binding DefaultViewModel, RelativeSource={RelativeSource Self}}". La proprietà DefaultViewModel è di tipo ObservableDictionary, che è una mappa delle stringhe (chiavi) agli oggetti (valori). DefaultViewModel viene fornito per comodità e può essere modificato in un modello di visualizzazione fortemente tipizzato, se necessario.

Ogni pagina è quindi associata alle proprietà che devono essere impostate nel DefaultViewModel nel code-behind. Considera l'esempio di GroupedItemsPage. In questa pagina CollectionViewSource presenta la proprietà Source associata alla proprietà Groups (Source="{Binding Groups}". Groups è la chiave di una coppia chiave-valore archiviata in DefaultViewModel (this.DefaultViewModel["Groups"] = sampleDataGroups;).

Mapping dello stato di visualizzazione allo stato visivo dell'applicazione

Nei modelli forniti per Windows 8, LayoutAwarePage fornisce il codice necessario per gestire lo stato della visualizzazione, ma questo codice non è più necessario in Windows 8.1. Il codice per gestire lo stato della visualizzazione è incluso solo nelle pagine SplitPage e FileOpenPicker. È ora previsto che ogni pagina gestisca tutte le dimensioni di finestra con una larghezza di almeno 500 pixel.

NavigationHelper registra i comandi per GoBack e GoForward. Queste implementazioni controllano se alla pagina è associato un Frame e, in questo caso, se il frame può spostarsi indietro o avanti prima della chiamata a Frame.GoBack() o Frame.GoForward(). È possibile sovrascrivere questo elemento per modificare il comportamento predefinito come per la pagina divisa.

NavigationHelper registra inoltre le scelte rapide con il mouse e i tasti di scelta rapida comunemente usati per la navigazione. Per tornare indietro vengono usati il pulsante del mouse Indietro, "ALT + tasto freccia sinistra", e il tasto della tastiera Indietro. Per andare avanti vengono usati il pulsante del mouse Avanti, "ALT + tasto freccia destra", e il tasto della tastiera Avanti.

Gestione durata dei processi

Oltre a fornire le implementazioni descritte in precedenza, NavigationHelper deve anche essere chiamato dai gestori eventi OnNavigatedTo() e OnNavigatedFrom() che sono implementati in ogni pagina. Quando si verificano tali eventi, NavigationHelper chiama un'implementazione specifica della pagina di LoadState() e SaveState(). Puoi personalizzare l'implementazione di queste funzioni in ogni pagina. Tali eventi devono essere usati rispettivamente al posto di OnNavigatedTo() e OnNavigatedFrom().

OnNavigatedFrom() viene chiamato quando la pagina è in procinto di essere visualizzata in un Frame. Quando ci spostiamo in una nuova pagina, carichiamo lo stato associato a tale pagina. Se è in corso il ripristino della pagina, ne viene recuperato lo stato salvato in precedenza. Viene quindi chiamato LoadState in modo che ogni pagina possa reagire. LoadState include due parametri, ovvero il parametro di navigazione originale passato in OnNavigatedTo e lo stato precedente della pagina, se disponibile.

OnNavigatedFrom() viene chiamato se la pagina non verrà più visualizzata in un Frame. Quando abbandoniamo una pagina, permettiamo che la pagina salvi il proprio stato corrente. Viene passato un dizionario vuoto a SaveState(). Ogni pagina può eseguire l'override di SaveState e archiviare gli oggetti nel dizionario con chiave (stringa a oggetto). Tale dizionario viene quindi associato alla pagina e aggiunto al SessionState di cui SuspensionManager tiene traccia per il frame in questione.

Nota  

  • Tutti i dati archiviati nella singola pagina devono essere disponibili per poter essere serializzati da DataContractSerializer. Per altre informazioni, vedi la discussione relativa a SuspensionManager all'inizio di questo argomento.
  • È anche importante archiviare solo le informazioni temporanee dell'interfaccia utente, in quanto questo stato andrà perso se l'app non verrà chiusa specificando Terminated.

Struttura di un'app

Per comprendere la struttura di un'app useremo un'app creata con il modello di progetto Applicazione griglia. La posizione di partenza per tutte le app di Windows Store che usano XAML è l'oggetto Application in App.xaml e il code-behind ad esso associato. Il primo codice eseguito quando viene creata l'app è il costruttore dell'app. Successivamente, viene chiamato uno dei diversi metodi di attivazione disponibili. In questo caso sarà l'evento OnLaunched quando l'app viene avviata da un riquadro della schermata iniziale. In questa chiamata viene creato un Frame, gli stati precedenti vengono ricaricati (se in precedenza l'app è stata interrotta) e viene usato il frame per passare alla prima pagina. Quando passiamo a una pagina, il gestore eventi OnNavigatedTo nella pagina chiama NavigationHelper. NavigationHelper viene eseguito, registra i parametri e ricarica le eventuali informazioni sullo stato precedente della pagina in questione. Chiama quindi il metodo LoadState() sottoposto a override in GroupedItemsPage. Qui i dati vengono caricati e il modello di visualizzazione predefinito viene popolato. Quando ci spostiamo su un'altra pagina, il gestore eventi OnNavigatedFrom chiama NavigationHelper, che salva lo stato della pagina chiamando SaveState(). SaveState() viene sottoposto a override in pagine che presentano uno stato dell'interfaccia utente temporaneo, ad esempio SplitPage, prima di passare alla nuova pagina e chiamare di nuovo il metodo LoadState().

Argomenti correlati

Modelli di progetto C#, VB e C++ per le app di Windows Store

Parte 2: Gestire il ciclo di vita e lo stato dell'app

Parte 3: Navigazione, layout e visualizzazioni