Isolated Storage: memorizziamo i settings della nostra applicazione – Parte 1: un primo approccio

Print Content | More

Dopo aver visto un’infarinatura sull’Isolated Storage, siamo pronti per iniziare ad utilizzarlo per salvare le impostazioni della nostra applicazione. Se si trattasse di una applicazione desktop tradizionale, una delle scelte migliori per un’esigenza di questo tipo sarebbe il formato XML: potremmo salvare su disco un file XML con le nostre impostazioni, da leggere in fase di avvio. .NET usa proprio questo meccanismo nelle applicazioni, supportando dei file di configurazione (tipicamente con estensione .config) e mettendoci a disposizione il dictionary ConfigurationManager.AppSettings per leggere e scrivere agilmente questo file (senza doverci preoccupare di creare a mano l’XML o di fare il parsing manuale per leggere le informazioni).

La classe IsolatedStorageSettings fa la stessa cosa: questa classe, infatti, ci mette a disposizione un dictionary, dove possiamo memorizzare delle coppie chiave / valore. La differenza rispetto al dictionary ConfigurationManager.AppSettings è che, trattandosi di un file XML, possiamo inserire solo coppie chiave / valore definite come string, string, mentre tramite la classe IsolatedStorageSettings possiamo memorizzare coppie definite come string, object.

Come utilizzare la classe IsolatedStorageSettings

Per iniziare ad utilizzare la classe IsolatedStorageSettings, non dobbiamo far altro che inizializzarla in questo modo:

IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings;

Dopodichè possiamo iniziare a scrivere e leggere dall’oggetto settings come facciamo con qualsiasi altro dictionary. Vedremo ora due modi differenti di gestire i settings della nostra applicazione.

Il modo più semplice : gestiamo tutto nel code behind

Il metodo più semplice e veloce per utilizzare la classe IsolatedStorageSettings è di costruire il nostro form con le impostazioni per configurare la nostra applicazione e gestire le operazioni di scrittura / lettura direttamente nel code behind. Nello specifico, quello che andremo a fare sarà:

  • Leggere i dati dall’oggetto settings quando la pagina viene inizializzata.
  • Inserire un pulsante di conferma per salvare le impostazioni; quando viene premuto, i dati vengono salvati nell’oggetto settings.

Facciamo una prova realizzando una semplice applicazione, che permetta di configurare il nome, il sesso e e le tecnologie di sviluppo Microsoft conosciute dall’utente. Apriamo Visual Studio 2010, creiamo un nuovo progetto di tipo Silverlight for Windows Phone e, nel file MainPage.xaml, inseriamo il seguente codice nella ContentGrid:

<StackPanel Margin="5">
    <TextBlock Text="Name"></TextBlock>
    <TextBox x:Name="txtName"></TextBox>
    <TextBlock Text="Sex"></TextBlock>
    <StackPanel Orientation="Horizontal">
        <RadioButton x:Name="rMale" GroupName="Sex" Content="Male"></RadioButton>
        <RadioButton x:Name="rFemale" GroupName="Sex" Content="Female"></RadioButton>
    </StackPanel>
    <TextBlock Text="Knowledge"></TextBlock>
    <StackPanel Orientation="Horizontal">
        <CheckBox x:Name="cbAsp" Content="ASP.NET"></CheckBox>
        <CheckBox x:Name="cbSilverlight" Content="Silverlight"></CheckBox>
    </StackPanel>
    <Button x:Name="btnSave" Content="Save settings" Click="btnSave_Click"></Button>
</StackPanel>

Come potete intuire, le tre impostazioni vengono gestite in tre modi diversi:

  • Il nome viene chiesto tramite una Textbox
  • Il sesso viene chiesto tramite due RadioButton (dato che si tratta di una scelta esclusiva)
  • La tecnologia di sviluppo conosciuta viene chiesta tramite due Checkbox (dato che l’utente può anche scegliere entrambe)

Ecco il codice con cui andiamo a salvare, con il click sul pulsante, le varie impostazioni:

private void btnSave_Click(object sender, RoutedEventArgs e)
{
    IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings;
    //Name
    if (settings.Contains("Name"))
        settings.Remove("Name");
    settings.Add("Name", txtName.Text);
    
    //Sex
    string sex = string.Empty;

    if (rMale.IsChecked==true)
        sex = "Male";
    if (rFemale.IsChecked == true)
        sex = "Female";

    if (settings.Contains("Sex"))
        settings.Remove("Sex");
    settings.Add("Sex", sex);

    List<string> knowledge=new List<string>();
    if (cbAsp.IsChecked==true)
        knowledge.Add("ASP.NET");
    if (cbSilverlight.IsChecked==true)
        knowledge.Add("Silverlight");

    if (knowledge.Count > 0)
    {
        if (settings.Contains("Knowledge"))
            settings.Remove("Knowledge");
        settings.Add("Knowledge", knowledge);
    }

    settings.Save();
}

Il codice è piuttosto semplice da capire: per ognuna delle impostazioni, andiamo a salvare nell’oggetto settings una chiave con il relativo valore. Come possiamo vedere nel caso della chiave Knowledge, abbiamo la possibilità di salvare non solo semplici stringhe (come nel caso delle chiavi Name e Sex) ma anche veri e propri oggetti (nel caso specifico, una collezione di tipo List). Il metodo Save(), chiamato alla fine, forza il salvataggio dei dati: in condizioni normali, infatti, il salvataggio avviene in automatico nel momento in cui la pagina viene chiusa. Se l’applicazione però viene sospesa, rischiamo di perdere tutto anche se l’utente ha già premuto il pulsante Save Settings.

Dato che in un dictionary non possiamo inserire due volte la stessa chiave, dobbiamo sempre ricordarci di verificare se questa esiste già e, in caso affermativo, eliminarla prima di aggiungere il valore.

Ecco invece il codice con cui andiamo a leggere, in fase di inizializzazione della pagina, i settings:

private void LoadSettings()
{
    IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings;
    if (settings.Contains("Name"))
        txtName.Text = settings["Name"].ToString();

    if (settings.Contains("Sex"))
    {
        string sex = string.Empty;
        sex = settings["Sex"].ToString();

        switch (sex)
        {
            case "Male":
                rMale.IsChecked = true;
                break;
            case "Female":
                rFemale.IsChecked = true;
                break;
        }
    }

    if (settings.Contains("Knowledge"))
    {
        List<string> knowledge = (List<string>) settings["Knowledge"];
        if (knowledge.Contains("ASP.NET"))
            cbAsp.IsChecked = true;
        if (knowledge.Contains("Silverlight"))
            cbSilverlight.IsChecked = true;
    }
        
}

Come potete vedere, anche questo codice è piuttosto semplice da capire: se il dictionary contiene le tre chiavi Name, Sex e Knowledge, ne recuperiamo il valore e lo utilizziamo per impostare opportunamente il controllo.

La caratteristica del sistema che abbiamo appena visto è che le impostazioni non vengono salvate fino a che non premiamo il pulsante Save settings: sta a noi decidere se questo è un vantaggio o uno svantaggio. Il punto di forza è che l’utente ha modo di annullare le modifiche che ha fatto, nel caso cambi idea: basta che prema il pulsante Back per tornare alla pagina precedente senza salvare le impostazioni. Il punto debole è che siamo costretti a salvare in un tombstone ogni impostazione: il rischio, infatti, è che l’utente perda le modifiche nel caso in cui l’applicazione venga sospesa.

Il modo che abbiamo visto per gestire i settings, però, è un po’ “grezzo”: nel prossimo post vedremo un approccio alternativo, più pulito e che ci permette, volendo, di sfruttare, il binding di Silverlight. Scopo di questo post, infatti, era quello di farvi familiarizzare con la classe IsolatedStorageSettings, così da capirne i meccanismi di scrittura e lettura.

Di seguito trovate il codice d’esempio di questa applicazione.


Windows Phone , Microsoft , Isolated Storage

1 comments

Related Post

  1. #1 da Daniele Monday August 2012 alle 11:23

    Volevo ringraziarti per questa guida, veramente la migliore che ho trovato, semplice e diretta. Grazie


(will not be published)
(es: http://www.mysite.com)