WinRT

Windows 8, WinRT, ApplicationData, Settings Charm

Ciao a tutti,
prima di riprendere con gli articoli legati all’uso del Pattern MVVM sulle Windows 8 Apps, parleremo di come manipolare i settings localmente.

La prima cosa che balza all’occhio quando si è davanti ad un progetto Windows 8 Store App e che non abbiamo più a disposizione il file App.Config, ormai storico compagno da anni 🙂 (che nel bene o nel male ci permetteva di salvare parti di configurazione in modo molto rapido)

Quindi la domanda successiva è: Come posso gestire i miei Settings?

WinRT ci fornisce diverse nuove API pronte all’uso che ci rendono il lavoro molto più semplice è veloce per manipolare, caricare, memorizzare i nostri dati.

Facciamo un passo indietro, prima di vedere come è possibile manipolare dei dati in locale dobbiamo conoscere cosa avviene dietro le quinte durante un Deploy piuttosto che un Download/Installazione dallo Store.

Windows 8 crea per noi una folder dove risiede il nostro Package (App) e una cartella sotto il path: user/appdata/local/packages/ dove possiamo liberamente andare a scrivere, leggere, creare cartelle, manipolare dati.

<code
//Qui la struttura di esempio dopo un Deploy
MyAppFolder
– (installazione dell'App e Folder Dedicata)

// Qui AppDataFolder per MyAppFolder
user/appdata/local/packages/
– LocalState
– RoamingState
– TempState
– Settings

Ecco come accedere alle rispettive Folder/Settings sopra descritte:

//Roaming
Windows.Storage.ApplicationData.Current.RoamingFolder
Windows.Storage.ApplicationData.Current.RoamingSettings

//Local
Windows.Storage.ApplicationData.Current.LocalFolder
Windows.Storage.ApplicationData.Current.LocalSettings

//Temp
Windows.Storage.ApplicationData.Current.TemporaryFolder

– Settings: semplici settaggi accessibili dalla “Settings Charm” che possono essere sincronizzati tra macchine (Roaming)
– LocalSettings: dati persistenti tra le sessioni di un App
– Temporary: dati in cache temporanea utilizzata come area di lavoro, garantiscono ottime prestazioni.

Qui il <link> per il download degli esempi.

Un breve esempio di come scrivere i nostri Settings, l’accesso e tramite IDictionary quindi i tipi base a disposizione in WinRT:

//RoamingSettings
Windows.Storage.ApplicationData.Current.RoamingSettings.Values[“MyRoamingSetting] = MyRoamingValue;

//LocalSettings
Windows.Storage.ApplicationData.Current.LocalSettings.Values[“MyLocalSetting] = MyLocalValue;

Quando usiamo i RoamingSettings è perchè abbiamo pensato ad una possibile installazione dell’App su più Device che accedono con la stessa utenza, a questo punto Windows 8 sincronizzerà per noi il contenuto.

Ora vi mostro un esempio di classe in grado di gestire dei Settings:

// SettingsHelper
public static class SettingsHelper
{
public static ApplicationDataContainer SettingsContainer { get; set; }

static SettingsStore()
{
SettingsContainer = ApplicationData.Current.LocalSettings;

/* SettingsContainer = ApplicationData.Current.RoamingSettings; */
}

///

/// AppName
///

public static string AppName
{
get { return SettingsContainer.Values["AppName"] as string; }
set { SettingsContainer.Values["AppName"] = value; }
}

///

/// RootFolder
///

public static string RootFolder
{
get { return SettingsContainer.Values["RootFolder"] as string; }
set { SettingsContainer.Values["RootFolder"] = value; }
}
}

Come possiamo notare, molto velocemente siamo in grado di cambiare il settings su cui andremo a leggere/scrivere senza modificare la rimanenza del codice.
Questo esempio di classe è utilizzabile con la SettingsCharm, chiaro dovremo aggiungere 2 funzionalità per fare il Load/Save dei dati. 🙂

Buon Windows 8 App a tutti!!! 🙂
Maurizio

Windows 8, WinRT, MVVM and NavigationService

Ciao a tutti,
oggi inizieremo con una serie di post/articoli che parleranno di come applicare MVVM alle Windows 8 Apps.

Chi viene dallo sviluppo di Applicazioni per Windows Phone si sarà già imbattuto e quindi saprà bene come risolvere il problema del NavigationService.

Il NavigationService è quella classe che ci permette di effettuare la navigazione in stile browser nelle nostre applicazioni Windows 8 e Windows Phone (per maggiori dettagli sulla classe visitate il link su MSDN).

Normalmente utilizzeremo il NavigationService quando abbiamo la necessità di cambiare pagina magari al variare di una Proprietà piuttosto che sull’azione associata ad un determinato comando.
L’unico problema che salta subito all’occhio è che il NavigationService è accessibile solo tramite il Code Behind della pagina e quindi non accessibile dal nostro ViewModel.

Per risolvere questo problema ci sono diverse soluzioni, la più elegante è quella di implementare un wrapper del NavigationService… ecco qui un snippet di esempio:

//Interfaccia INavigationService
public interface INavigationService
{
void GoBack();
void GoForward();
bool Navigate(object parameter = null);
bool Navigate(Type source, object parameter = null);
}

//NavigationHelper
public class NavigationService : INavigationService
{
private Frame rootFrame { get; set; }

//Qui passeremo come parametro il Frame initializzato nel App.cs
public NavigationHelper(Frame rootFrame)
{
this.rootFrame = rootFrame;
}

public void GoBack()
{
this.rootFrame.GoBack();
}

public void GoForward()
{
this.rootFrame.GoForward();
}

public bool Navigate(object parameter = null)
{
return this.rootFrame.Navigate(typeof(T), parameter);
}

public bool Navigate(Type source, object parameter = null)
{
return this.Navigate(source, parameter);
}
}

Quindi, abbiamo definito un’interfaccia che in sostanza espone le stesse funzionalità di navigazione che avremmo a disposizione nel NavigationService presente nel Code Behind e di seguito la sua implementazione.

Ora non ci rimane che inizializzare il nostro NavigationService nell’App.xaml.cs tramite Dependency Injection (IOC).
Per quanto rigurda IOC possiamo utilizzare qualsiasi soluzione compatibile con WinRT, io come sempre consiglio Galasoft Toolkit di Laurent Bugnion.

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
var rootFrame = new Frame();
if (args.PreviousExecutionState == ApplicationExecutionState.Running)
{
Window.Current.Activate();
return;
}

if (args.PreviousExecutionState == ApplicationExecutionState.Terminated || args.PreviousExecutionState==ApplicationExecutionState.NotRunning)
{
SimpleIoc.Default.Register(typeof (INavigationService), new NavigationService(rootFrame));
}

if (!rootFrame.Navigate(typeof(MainPage)))
{
throw new Exception("Failed to create initial page");
}

// Place the frame in the current Window and ensure that it is active
Window.Current.Content = rootFrame;
Window.Current.Activate();
}

Nell’esempio andiamo a registrare l’istanza del NavigationService nel momento in cui l’App si trova diciamo “In Stato di Fermo” 😀

“SimpleIoc” fa riferimento all’utilizzo del Galasoft Toolkit dove di “default” introduce il ViewModelLocator con un’implementazione di IOC chiamata appunto SimpleIoc.

Nei nostri ViewModel avremo così a disposizione il nostro NavigationService:

protected INavigationService navigationService;

public MyViewModel(INavigationService navigationService)
{
this.navigationService = navigationService;
}

A questo punto non vi rimane che divertirvi con i vostri ViewModel e le vostre Apps di Windows 8 😀

Credo di aver raccontato tutto 😀
Buon Windows 8 Apps!!!

Maurizio

MetroNote App for Windows Store – Release 2

MetroNote App for Windows 8 Store
E’ ufficialmente pubblicata la nuova major release di MetroNote, l’Applicazione che permette la completa gestione dei vostri Post-it/Memo che ora è diventata GRATUITA.

Quali sono le nuove funzionalità? MetroNote consentirà di:
– cambiare tema (“metal” o “wood”) dello sfondo
– cambiare il colore delle note
– inserire un mark sulle note più importanti
– condividere le note tramite la Share Charm
– aggiungere le note alla Start
… e altro ancora! Aspettate e vedrete!

Ecco il link per vederla sul Windows Store: MetroNote

Maurizio