+ Gestire la persistenza Nicolò Sordoni

+ Meccanismi di persistenza dei dati In Windows Phone, come negli altri ambienti, abbiamo tre soluzioni principali per il salvataggio di informazioni persistenti: LocalSettings : funge da contenitore per le impostazioni della nostra applicazione. Storage : permette di salvare le informazioni all’interno di files, che saranno salvati in un’area a cui solamente la nostra app (oltre al S.O.) avrà accesso. Database locale : In Windows Phone è possibile utilizzare un’istanza dedicata di SQL CE, una versione di SQL Server sviluppata ad hoc per il salvataggio locale delle informazioni.

+ LocalSettings I LocalSettings sono stati concepiti per memorizzare impostazioni relative alla nostra app. Forniscono uno strumento di utilizzo immediato per salvare qualsiasi informazione dell’applicazione, a patto che la sua dimensione non superi gli 8Kb. Possono essere paragonati alle SharedPreferences di Android. L’oggetto che ci consente di gestire queste impostazioni è accessibile tramite la property ApplicationData.Current.LocalSettings ed è di tipo ApplicationDataContainer (namespace Windows.Storage). Tale oggetto espone la proprietà Values, cioè un array associativo all’interno del quale possiamo salvare le informazioni tramite una logica chiave/valore.

+ LocalSettings L’esempio precedente mostra come utilizzare le impostazioni locali. Una volta ottenuto il riferimento all’istanza, è possibile utilizzare l’attributo Values per: Verificare l’esistenza di una chiave salvata in precedenza. Accedere ad valore utilizzando la rispettiva chiave Inserire una coppia chiave valore Eliminare un valore (metodo Remove).

+ LocalSettings Ogni volta che un valore viene aggiunto/rimosso/modificato, la modifica viene automaticamente salvata in maniera persistente, pertanto, anche riavviando l’applicazione, sarà possibile recuperare il valore. Questo meccanismo è stato concepito per informazioni di dimensione ridotta, mentre per memorizzare informazioni più complesse, come elenchi, immagini, ecc. è necessario fare uso di uno degli altri due metodi.

+ Storage Oltre all’utilizzo dei LocalSettings, la soluzione più semplice ed immediata da attuare in termini di tempi di sviluppo è l’utilizzo del File System. Ogni applicazione ha accesso alle seguenti 3 cartelle: Local Folder : una cartella locale alla quale solamente l’applicazione può accedere, sia in lettura che in scittura. Application Folder : la cartella in cui è installata l’app (accessibile in sola lettura). SD Card : accessibile solamente in lettura.

+ Storage La cartella che useremo più di frequente sarà sicuramente quella locale, dato che è l’unica in cui possiamo anche scrivere. E’ necessario innanzitutto importare il namespace che contiene le classi necessarie a lavorare con i files, cioè Windows.Storage. La variabile ApplicationData.Current.LocalFolder ci permette di accedere alla nostra cartella locale. A questo punto siamo in grado di creare un nuovo file, invocando, su tale oggetto, il seguente metodo: StorageFile CreateFileAsync(String fileName, CreationCollisionOption option)

+ Creazione di un file Il metodo appena definito (che è un metodo asincrono) restituisce un oggetto di tipo StorageFile, cioè un file ed accetta in ingresso due parametri: il nome del file ed un enum che indica quale comportamente tenere in caso esista già un file preesistente con lo stesso nome. I valori ammessi sono: FailIfExists : restituisce un errore in caso il file esista già. GenerateUniqueName : genera un nuovo file con un nome univoco OpenIfExists : Anzichè creare un nuovo file, apre quello preesistente. ReplaceExisting : Il vecchio file viene rimpiazzato dal nuovo.

+ Scrivere su file Per scrivere informazioni all’interno di un file, il metodo più semplice è l’utilizzo di un oggetto di tipo DataWriter. Tale oggetto ci consente di inserire solamente i tipi base (String, Int, FLoat, DateTime,...), mentre per inserire oggetti differenti è necessario far uso della serializzazione, che vedremo in seguito.

+ Scrivere su file L’esempio ci mostra come inserire informazioni all’interno del nostro file. E’ necessario innanzitutto creare il file. Dopodichè dobbiamo aprirlo, richiedendo i permessi di lettura e scrittura, ottenendo il riferimento ad un oggetto di tipo RandomAccessStream. Per scrivere sul file dobbiamo creare un’istanza di DataWriter. Lo inizializziamo tramite un apposito costruttore a cui passiamo il riferimento ad uno stream che ci consente di scrivere sul file. Il metodo randomAccessStream.GetOutputStreamAt() ci consente di ottenere tale risultato; il parametro che accetta in input serve per indicare da quale posizione iniziare la scrittura. la keyword using consente di definire un’oggetto che sarà deallocato al termine del corrispondente blocco.

+ Scrivere su file Per effettuare la scrittura vera e propria è sufficiente utilizzare i vari metodo Write messi a disposizione dalla classe DataWriter (WriteString, WriteDouble, WriteDateTime,...). Una volta completata la scrittura dei valori, è necessario effettuare il commit, tramite il metodo StoreAsync(), che provvederà all’inserimento effettivo all’interno del file. Infine, il metodo FlushAsync è necessario per liberare lo stream e completare l’operazione.

+ Leggere da file Per leggere le informazioni da un file, il procedimento è simile a quanto visto per la scrittura. Il metodo da invocare inizialmente in questo caso non è CreateFileAsync, ma GetFilesAsync, passando come parametro il nome del file. E’ sempre necessario aprire un RandomAccessStream, ma in questo caso sono sufficienti i permessi di lettura.

+ Leggere da file La classe che ci consente la lettura delle informazioni è il DataReader. Per inizializzare una sua istanza in questo caso abbiamo bisogno di ottenere l’InputStream, iniziando la lettura sempre dalla posizione 0. Prima di poter procedere alla lettura, è necessario ottenere la dimensione del file, per sapere quanti byte dovranno essere letti. Una volta fatto, è necessario utilizzare i metodi Read (as esempio ReadString) di tale classe.

+ La serializzazione Il metodo che abbiamo appena osservato presenta numerosi limiti. Non è possibile memorizzare dati differenti dai tipi base e la lettura di un file in cui vengono salvate più informazioni di tipo differente può risultare non poco complessa. Per ovviare a questi limiti, il sistema ci offre la possibilità di serializzare gli oggetti delle nostre classi. Serializzare significa trasformare oggetti complessi in formati adatti ad essere scritti su file. I più utilizzati sono XML e JSON. Il processo inverso è la deserializzazione, che, a partire da informazioni testuali strutturate, è in grado di ricostruire gli oggetti in memoria.

+ La serializzazione Per poter serializzare una classe, è necessario indicare al sistema quali, fra i suoi attributi, potranno essere serializzati. Per farlo, il C# prevede la seguente sintassi: DataContract : indica che la classe può essere serializzata. Nel caso non venga specificato, si potrebbe avere un runtime error. DataMember : identifica un attributo che può essere serializzato.

+ La serializzazione La classe responsabile dell’effettiva serializzazione, è DataContractSerializer, definita nel namespace System. Runtime.Serialization. Per inizializzarla è necessario passare al costruttore il tipo di dato che dovrà essere serializzato. Una volta inizializzato il serializer è necessario creare e/o aprire il file in lettura e scrittura, ottenendo il riferimento al solito RandomAccesStream. Arrivati a questo punto, tutto ciò che è sufficiente fare, per completare la serializzazione, è ottenere uno stream per scrivere sul file ed invocare il metodo WriteObject della classe DataContractSerializer.

+ La serializzazione La classe DataContractSerializer salva tutti gli oggetti in XML; per questo motivo, l’estensione scelta per il file è.xml.

+ Serializzazione in JSON Se al posto dell’XML volessimo usare il formato JSON, è sufficiente modificare la seguente istruzione (ed ovviamente l’estensione del file in cui sono salvati i dati):

+ Deserializzazione Per deserializzare le informazioni salvate in precedenza, è sufficiente inizializzare un’istanza della classe DataContractSerializer ed aprire il file in lettura. Dopodichè otteniamo, dal RandomAccessStream, uno stream per leggere dal file, ed infine effettuiamo la deserializzazione delle informazioni, tramite downcast al tipo corretto.