Archiviare e recuperare impostazioni e altri dati dell'app

I dati dell'app sono dati modificabili creati e gestiti da un'app specifica. Include lo stato di runtime, le impostazioni dell'app, le preferenze utente, il contenuto di riferimento (ad esempio le definizioni del dizionario in un'app dizionario) e altre impostazioni. I dati dell'app sono diversi dai dati utente, dai dati creati e gestiti dall'utente quando si usa un'app. I dati utente includono file di documenti o file multimediali, trascrizioni di posta elettronica o comunicazione o record di database che contengono contenuto creato dall'utente. I dati utente possono essere utili o significativi per più di un'app. Spesso si tratta di dati che l'utente vuole modificare o trasmettere come entità indipendente dall'app stessa, ad esempio un documento.

Nota importante sui dati dell'app: La durata dei dati dell'app è associata alla durata dell'app. Se l'app viene rimossa, tutti i dati dell'app andranno persi di conseguenza. Non usare i dati dell'app per archiviare i dati utente o qualsiasi elemento che gli utenti possano percepire come prezioso e insostituibile. È consigliabile usare le librerie dell'utente e Microsoft OneDrive per archiviare questo tipo di informazioni. I dati dell'app sono ideali per archiviare preferenze, impostazioni e preferiti specifici dell'app.

Tipi di dati dell'app

Esistono due tipi di dati dell'app: impostazioni e file.

Settings

Usare le impostazioni per archiviare le preferenze utente e le informazioni sullo stato dell'applicazione. L'API dei dati dell'app consente di creare e recuperare facilmente le impostazioni (verranno illustrati alcuni esempi più avanti in questo articolo).

Ecco i tipi di dati che è possibile usare per le impostazioni dell'app:

• UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double
• Booleano
• Char16, String
• DateTime, TimeSpan
  • Per C#/.NET, usare: System.DateTimeOffset, System.TimeSpan
• GUID, Punto, Dimensione, Rettangolo
• ApplicationDataCompositeValue: set di impostazioni dell'app correlate che devono essere serializzate e deserializzate in modo atomico. Usare le impostazioni composite per gestire facilmente gli aggiornamenti atomici delle impostazioni interdipendenti. Il sistema garantisce l'integrità delle impostazioni composite durante l'accesso simultaneo e il roaming. Le impostazioni composite sono ottimizzate per piccole quantità di dati e le prestazioni possono risultare scarse se vengono usate per set di dati di grandi dimensioni.

File

Usare i file per archiviare dati binari o per abilitare tipi serializzati personalizzati.

Archiviazione dei dati dell'app negli archivi dati dell'app

Quando un'app viene installata, il sistema fornisce i propri archivi dati per utente per impostazioni e file. Non è necessario sapere dove o come esistono questi dati, perché il sistema è responsabile della gestione dell'archiviazione fisica, assicurandosi che i dati vengano mantenuti isolati da altre app e da altri utenti. Il sistema mantiene in genere il contenuto di questi archivi dati quando l'utente installa un aggiornamento all'app, anche se RoamingSettings potrebbe non essere persistente tramite gli aggiornamenti Microsoft Store (vedere Dati diroaming). Per le impostazioni che devono sopravvivere agli aggiornamenti delle app, usare LocalSettings. Il sistema rimuove completamente il contenuto di questi archivi dati e pulisce quando l'app viene disinstallata.

All'interno dell'archivio dati dell'app, ogni app ha directory radice definite dal sistema: una per i file locali, una per i file mobili e una per i file temporanei. L'app può aggiungere nuovi file e nuovi contenitori a ognuna di queste directory radice.

Dati dell'app locale

I dati dell'app locale devono essere usati per tutte le informazioni che devono essere mantenute tra le sessioni dell'app e non sono adatti per i dati mobili delle app. Anche i dati non applicabili in altri dispositivi devono essere archiviati qui. Non esiste alcuna restrizione generale sulle dimensioni dei dati locali archiviati. Usare l'archivio dati dell'app locale per i dati che non è necessario sincronizzare e per set di dati di grandi dimensioni. I dati locali dell'app vengono mantenuti in modo affidabile attraverso gli aggiornamenti dell'app, rendendo LocalSettings la scelta consigliata per le preferenze utente e lo stato dell'app che devono sopravvivere agli aggiornamenti dello Store Microsoft.

Recuperare l'archivio dati dell'app locale

Prima di poter leggere o scrivere dati dell'app locale, è necessario recuperare l'archivio dati dell'app locale. Per recuperare l'archivio dati dell'app locale, usare la proprietà ApplicationData.LocalSettings per ottenere le impostazioni locali dell'app come oggetto ApplicationDataContainer. Utilizzare la proprietà ApplicationData.LocalFolder per ottenere i file in un oggetto StorageFolder. Usare la proprietà ApplicationData.LocalCacheFolder per ottenere la cartella nell'archivio dati dell'app locale in cui è possibile salvare i file non inclusi nel backup e nel ripristino.

Windows.Storage.ApplicationDataContainer localSettings = 
    Windows.Storage.ApplicationData.Current.LocalSettings;
Windows.Storage.StorageFolder localFolder = 
    Windows.Storage.ApplicationData.Current.LocalFolder;

Creare e recuperare una semplice impostazione locale

Per creare o scrivere un'impostazione, usare la proprietà ApplicationDataContainer.Values per accedere alle impostazioni nel localSettings contenitore ottenuto nel passaggio precedente. In questo esempio viene creata un'impostazione denominata exampleSetting.

// Simple setting

localSettings.Values["exampleSetting"] = "Hello Windows";

Per recuperare l'impostazione, usare la stessa proprietà ApplicationDataContainer.Values usata per creare l'impostazione. In questo esempio viene illustrato come recuperare l'impostazione appena creata.

// Simple setting
Object value = localSettings.Values["exampleSetting"];

Creare e recuperare un valore composito locale

Per creare o scrivere un valore composito, creare un oggetto ApplicationDataCompositeValue. Questo esempio crea un'impostazione composita denominata exampleCompositeSetting e la aggiunge al localSettings contenitore.

// Composite setting

Windows.Storage.ApplicationDataCompositeValue composite = 
    new Windows.Storage.ApplicationDataCompositeValue();
composite["intVal"] = 1;
composite["strVal"] = "string";

localSettings.Values["exampleCompositeSetting"] = composite;

In questo esempio viene illustrato come recuperare il valore composito appena creato.

// Composite setting

Windows.Storage.ApplicationDataCompositeValue composite = 
   (Windows.Storage.ApplicationDataCompositeValue)localSettings.Values["exampleCompositeSetting"];

if (composite == null)
{
   // No data
}
else
{
   // Access data in composite["intVal"] and composite["strVal"]
}

Creare e leggere un file locale

Per creare e aggiornare un file nell'archivio dati dell'app locale, usare le API file, ad esempio Windows. Storage.StorageFolder.CreateFileAsync e Windows. Storage.FileIO.WriteTextAsync. Questo esempio crea un file denominato dataFile.txt nel localFolder contenitore e scrive la data e l'ora correnti nel file. Il valore ReplaceExisting del CreationCollisionOption indica di sostituire il file se esiste già.

async void WriteTimestamp()
{
   Windows.Globalization.DateTimeFormatting.DateTimeFormatter formatter = 
       new Windows.Globalization.DateTimeFormatting.DateTimeFormatter("longtime");

   StorageFile sampleFile = await localFolder.CreateFileAsync("dataFile.txt", 
       CreationCollisionOption.ReplaceExisting);
   await FileIO.WriteTextAsync(sampleFile, formatter.Format(DateTimeOffset.Now));
}

Per aprire e leggere un file nell'archivio dati dell'app locale, usare le API file, ad esempio Windows. Storage.StorageFolder.GetFileAsync, Windows. Storage.StorageFile.GetFileFromApplicationUriAsync e Windows. Storage.FileIO.ReadTextAsync. Questo esempio apre il dataFile.txt file creato nel passaggio precedente e legge la data dal file. Per informazioni dettagliate sul caricamento di risorse di file da diverse posizioni, vedere Come caricare le risorse dei file.

async void ReadTimestamp()
{
   try
   {
      StorageFile sampleFile = await localFolder.GetFileAsync("dataFile.txt");
      String timestamp = await FileIO.ReadTextAsync(sampleFile);
      // Data is contained in timestamp
   }
   catch (Exception)
   {
      // Timestamp not found
   }
}

Dati mobili

Dati temporanei dell'app

L'archivio dati dell'app temporaneo funziona come una cache. I file non eseguono il roaming e possono essere rimossi in qualsiasi momento. L'attività Manutenzione sistema può eliminare automaticamente i dati archiviati in questa posizione in qualsiasi momento. L'utente può anche cancellare i file dall'archivio dati temporaneo usando Pulizia disco. I dati temporanei dell'app possono essere usati per archiviare informazioni temporanee durante una sessione dell'app. Non è garantito che questi dati vengano mantenuti oltre la fine della sessione dell'app perché il sistema potrebbe recuperare lo spazio usato, se necessario. Il percorso è disponibile tramite la proprietà temporaryFolder .

Recuperare il contenitore di dati temporanei

Utilizzare la proprietà ApplicationData.TemporaryFolder per ottenere i file. I passaggi successivi usano la temporaryFolder variabile di questo passaggio.

Windows.Storage.StorageFolder temporaryFolder = ApplicationData.Current.TemporaryFolder;

Creare e leggere file temporanei

Per creare e aggiornare un file nell'archivio dati temporaneo dell'app, usare le API di file, ad esempio Windows. Storage.StorageFolder.CreateFileAsync e Windows. Storage.FileIO.WriteTextAsync. Questo esempio crea un file denominato dataFile.txt nel temporaryFolder contenitore e scrive la data e l'ora correnti nel file. Il valore ReplaceExisting del CreationCollisionOption indica di sostituire il file se esiste già.

async void WriteTimestamp()
{
   Windows.Globalization.DateTimeFormatting.DateTimeFormatter formatter = 
       new Windows.Globalization.DateTimeFormatting.DateTimeFormatter("longtime");

   StorageFile sampleFile = await temporaryFolder.CreateFileAsync("dataFile.txt", 
       CreateCollisionOption.ReplaceExisting);
   await FileIO.WriteTextAsync(sampleFile, formatter.Format(DateTimeOffset.Now));
}

Per aprire e leggere un file nell'archivio dati temporaneo dell'app, usare le API di file, ad esempio Windows. Storage.StorageFolder.GetFileAsync, Windows. Storage.StorageFile.GetFileFromApplicationUriAsync e Windows. Storage.FileIO.ReadTextAsync. Questo esempio apre il dataFile.txt file creato nel passaggio precedente e legge la data dal file. Per informazioni dettagliate sul caricamento di risorse di file da diverse posizioni, vedere Come caricare le risorse dei file.

async void ReadTimestamp()
{
   try
   {
      StorageFile sampleFile = await temporaryFolder.GetFileAsync("dataFile.txt");
      String timestamp = await FileIO.ReadTextAsync(sampleFile);
      // Data is contained in timestamp
   }
   catch (Exception)
   {
      // Timestamp not found
   }
}

Organizzare i dati dell'app con i contenitori

Per organizzare le impostazioni e i file dei dati dell'app, è possibile creare contenitori (rappresentati da ApplicationDataContainer) anziché usare direttamente le directory. È possibile aggiungere contenitori agli archivi dati locali, mobili e temporanei dell'app. I contenitori possono essere annidati fino a una profondità di 32 livelli.

Per creare un contenitore di impostazioni, chiamare il metodo ApplicationDataContainer.CreateContainer . In questo esempio viene creato un contenitore di impostazioni locali denominato exampleContainer e viene aggiunta un'impostazione denominata exampleSetting. Il valore Always dell'enumerazione ApplicationDataCreateDisposition indica che il contenitore viene creato se non esiste già.

Windows.Storage.ApplicationDataContainer localSettings = 
    Windows.Storage.ApplicationData.Current.LocalSettings;
Windows.Storage.StorageFolder localFolder = 
    Windows.Storage.ApplicationData.Current.LocalFolder;

// Setting in a container
Windows.Storage.ApplicationDataContainer container = 
   localSettings.CreateContainer("exampleContainer", Windows.Storage.ApplicationDataCreateDisposition.Always);

if (localSettings.Containers.ContainsKey("exampleContainer"))
{
   localSettings.Containers["exampleContainer"].Values["exampleSetting"] = "Hello Windows";
}

Eliminare le impostazioni e i contenitori dell'app

Per eliminare una semplice impostazione non più necessaria per l'app, usa il metodo ApplicationDataContainerSettings.Remove . In questo esempio viene eliminata l'impostazione exampleSetting locale creata in precedenza.

Windows.Storage.ApplicationDataContainer localSettings = 
    Windows.Storage.ApplicationData.Current.LocalSettings;
Windows.Storage.StorageFolder localFolder = 
    Windows.Storage.ApplicationData.Current.LocalFolder;

// Delete simple setting

localSettings.Values.Remove("exampleSetting");

Per eliminare un'impostazione composita, usare il metodo ApplicationDataCompositeValue.Remove . In questo esempio viene eliminata l'impostazione composita locale exampleCompositeSetting creata in un esempio precedente.

Windows.Storage.ApplicationDataContainer localSettings = 
    Windows.Storage.ApplicationData.Current.LocalSettings;
Windows.Storage.StorageFolder localFolder = 
    Windows.Storage.ApplicationData.Current.LocalFolder;

// Delete composite setting

localSettings.Values.Remove("exampleCompositeSetting");

Per eliminare un contenitore, chiamare il metodo ApplicationDataContainer.DeleteContainer . In questo esempio viene eliminato il contenitore delle impostazioni locali exampleContainer creato in precedenza.

Windows.Storage.ApplicationDataContainer localSettings = 
    Windows.Storage.ApplicationData.Current.LocalSettings;
Windows.Storage.StorageFolder localFolder = 
    Windows.Storage.ApplicationData.Current.LocalFolder;

// Delete container

localSettings.DeleteContainer("exampleContainer");

Controllo delle versioni dei dati dell'app

È possibile, facoltativamente, versionare i dati dell'app. In questo modo puoi creare una versione futura della tua app che modifica il formato dei dati dell'app senza causare problemi di compatibilità con la versione precedente dell'app. L'app controlla la versione dei dati dell'app nell'archivio dati e se la versione è inferiore alla versione prevista dall'app, l'app deve aggiornare i dati dell'app al nuovo formato e aggiornare la versione. Per altre info, vedi la proprietàApplication.Version e il metodo ApplicationData.SetVersionAsync .

Articoli correlati

• Windows.Storage.ApplicationData
• Windows.Storage.ApplicationData.RoamingSettings
• Windows.Storage.ApplicationData.RoamingFolder
• Windows.Storage.ApplicationData.RoamingStorageQuota
• Windows.Storage.ApplicationDataCompositeValue