Condividi tramite

Archiviare e recuperare le impostazioni e altri dati dell'app

  • Articolo

I dati dell'app sono dati modificabili creati e gestiti da un'app specifica. Appartengono a questa categoria 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 di app

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

Impostazione

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,Stringa
  • DateTime, TimeSpan
  • GUID, Point, Size, Rect
  • ApplicationDataCompositeValue: un set di impostazioni dell'app correlate che è necessario serializzare e deserializzare 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 anche il contenuto di questi archivi dati quando l'utente installa un aggiornamento all'app e rimuove completamente il contenuto di questi archivi dati 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 hanno senso eseguire il roaming e per set di dati di grandi dimensioni.

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 una proprietà 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.Archiviazione. Archiviazione Folder.CreateFileAsync e Windows.Archiviazione. 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 dell'enumerazione 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 locale dell'app mobile, 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 in roaming

Avviso

I dati e le impostazioni mobili non sono più supportati a partire da Windows 11. La sostituzione consigliata è Servizio app di Azure. Servizio app di Azure è ampiamente supportato, ben documentato, affidabile e supporta scenari multi-piattaforma e multi-ambiente, come iOS, Android e Web.

La documentazione seguente si applica a Windows 10 versioni 1909 e precedenti.

Se usi i dati mobili nella tua app, gli utenti possono mantenere facilmente sincronizzati i dati dell'app dell'app tra più dispositivi. Se un utente installa l'app in più dispositivi, il sistema operativo mantiene sincronizzati i dati dell'app, riducendo la quantità di lavoro di installazione che l'utente deve eseguire per l'app nel secondo dispositivo. Il roaming consente anche agli utenti di continuare un'attività, ad esempio la composizione di un elenco, proprio dove sono rimasti anche su un dispositivo diverso. Il sistema operativo replica i dati mobili nel cloud quando viene aggiornato e sincronizza i dati con gli altri dispositivi in cui è installata l'app.

Il sistema operativo limita le dimensioni dei dati dell'app che ogni app può eseguire il roaming. Vedere ApplicationData.RoamingStorageQuota. Se l'app raggiunge questo limite, nessuno dei dati dell'app dell'app verrà replicato nel cloud fino a quando i dati totali dell'app sono inferiori al limite. Per questo motivo, è consigliabile usare i dati mobili solo per preferenze utente, collegamenti e file di dati di piccole dimensioni.

I dati mobili per un'app sono disponibili nel cloud, purché siano accessibili dall'utente da un dispositivo entro l'intervallo di tempo richiesto. Se l'utente non esegue un'app per più di questo intervallo di tempo, i dati mobili vengono rimossi dal cloud. Se un utente disinstalla un'app, i dati mobili non vengono rimossi automaticamente dal cloud, vengono mantenuti. Se l'utente reinstalla l'app entro l'intervallo di tempo, i dati mobili vengono sincronizzati dal cloud.

I dati mobili sono e non lo fanno

Vedere la nota importante sul roaming dei dati.

  • Usare il roaming per le preferenze e le personalizzazioni dell'utente, i collegamenti e i file di dati di piccole dimensioni. Ad esempio, usare il roaming per mantenere le preferenze di colore di sfondo di un utente in tutti i dispositivi.
  • Usare il roaming per consentire agli utenti di continuare un'attività tra dispositivi. Ad esempio, eseguire il roaming dei dati dell'app, ad esempio il contenuto di un messaggio di posta elettronica bozza o la pagina visualizzata più di recente in un'app lettore.
  • Gestire l'evento DataChanged aggiornando i dati dell'app. Questo evento si verifica quando i dati dell'app hanno appena terminato la sincronizzazione dal cloud.
  • Eseguire il roaming dei riferimenti al contenuto anziché ai dati non elaborati. Ad esempio, eseguire il roaming di un URL anziché il contenuto di un articolo online.
  • Per informazioni importanti, usare l'impostazione HighPriority associata a RoamingSettings.
  • Non eseguire il roaming dei dati dell'app specifici di un dispositivo. Alcune informazioni sono pertinenti solo in locale, ad esempio un nome di percorso a una risorsa file locale. Se decidi di eseguire il roaming delle informazioni locali, assicurati che l'app possa ripristinare se le informazioni non sono valide nel dispositivo secondario.
  • Non eseguire il roaming di grandi set di dati dell'app. Esiste un limite alla quantità di dati dell'app che un'app può eseguire il roaming; utilizzare la proprietà Roaming Archiviazione Quota per ottenere questo valore massimo. Se un'app raggiunge questo limite, non è possibile eseguire il roaming dei dati fino a quando le dimensioni dell'archivio dati dell'app non superano più il limite. Quando progetti l'app, valuta come inserire un limite su dati di dimensioni maggiori in modo da non superare il limite. Ad esempio, se il salvataggio di uno stato del gioco richiede 10 KB ciascuno, l'app potrebbe consentire solo all'utente di archiviare fino a 10 giochi.
  • Non usare il roaming per i dati che si basano sulla sincronizzazione immediata. Windows non garantisce una sincronizzazione immediata; il roaming potrebbe essere notevolmente ritardato se un utente è offline o in una rete ad alta latenza. Assicurarsi che l'interfaccia utente non dipende dalla sincronizzazione immediata.
  • Non usare il roaming per dati che cambiano di frequente. Ad esempio, se l'app tiene traccia delle informazioni che cambiano di frequente, ad esempio la posizione in un brano al secondo, non archiviare questa opzione come dati mobili dell'app. Selezionare invece una rappresentazione meno frequente che fornisce comunque un'esperienza utente ottimale, ad esempio la canzone attualmente in riproduzione.

Prerequisiti per il roaming

Vedere la nota importante sul roaming dei dati.

Qualsiasi utente può trarre vantaggio dai dati delle app mobili se usa un account Microsoft per accedere al dispositivo. Tuttavia, gli utenti e gli amministratori di Criteri di gruppo possono disattivare i dati delle app mobili in un dispositivo in qualsiasi momento. Se un utente decide di non usare un account Microsoft oppure disattiva le funzionalità per dati in roaming, potrà comunque usare l'app, ma i dati dell'app saranno quelli locali del dispositivo.

I dati archiviati in PasswordVault eseguiranno la transizione solo se un utente ha reso un dispositivo "attendibile". Se un dispositivo non è attendibile, i dati protetti in questo insieme di credenziali non verranno trasferiti.

Risoluzione dei conflitti

Vedere la nota importante sul roaming dei dati.

I dati delle app mobili non sono destinati all'uso simultaneo in più di un dispositivo alla volta. Se si verifica un conflitto durante la sincronizzazione perché una particolare unità dati è stata modificata in due dispositivi, il sistema favorirà sempre il valore scritto per ultimo. In questo modo l'app usa le informazioni più aggiornate. Se l'unità dati è un'impostazione composita, la risoluzione dei conflitti si verificherà comunque a livello dell'unità di impostazione, il che significa che il composito con la modifica più recente verrà sincronizzato.

Quando scrivere i dati

Vedere la nota importante sul roaming dei dati.

A seconda della durata prevista dell'impostazione, i dati devono essere scritti in momenti diversi. I dati delle app a modifica lenta o raramente devono essere scritti immediatamente. Tuttavia, i dati delle app che cambiano frequentemente devono essere scritti periodicamente solo a intervalli regolari (ad esempio una volta ogni 5 minuti), nonché quando l'app viene sospesa. Ad esempio, un'app musicale potrebbe scrivere le impostazioni di "brano corrente" ogni volta che inizia a riprodurre una nuova canzone, tuttavia, la posizione effettiva nella canzone deve essere scritta solo alla sospensione.

Protezione eccessiva dell'utilizzo

Vedere la nota importante sul roaming dei dati.

Il sistema dispone di vari meccanismi di protezione per evitare l'uso inappropriato delle risorse. Se i dati dell'app non passano come previsto, è probabile che il dispositivo sia stato temporaneamente limitato. L'attesa di un certo tempo risolverà automaticamente questa situazione e non è necessaria alcuna azione.

Controllo delle versioni

Vedere la nota importante sul roaming dei dati.

I dati dell'app possono usare il controllo delle versioni per eseguire l'aggiornamento da una struttura di dati a un'altra. Il numero di versione è diverso dalla versione dell'app e può essere impostato a volontà. Sebbene non venga applicata, è consigliabile usare numeri di versione crescenti, poiché potrebbero verificarsi complicazioni indesiderate (inclusa la perdita di dati) se si tenta di passare a un numero di versione dei dati inferiore che rappresenta i dati più recenti.

I dati dell'app si spostano solo tra le app installate con lo stesso numero di versione. Ad esempio, i dispositivi nella versione 2 eseguiranno la transizione dei dati tra loro e i dispositivi nella versione 3, ma non si verificherà alcun roaming tra un dispositivo che esegue la versione 2 e un dispositivo che esegue la versione 3. Se installi una nuova app che utilizza vari numeri di versione in altri dispositivi, l'app appena installata sincronizzerà i dati dell'app associati al numero di versione più alto.

Test e strumenti

Vedere la nota importante sul roaming dei dati.

Gli sviluppatori possono bloccare il dispositivo per attivare una sincronizzazione dei dati mobili delle app. Se sembra che i dati dell'app non vengano trasferiti entro un determinato intervallo di tempo, controllare gli elementi seguenti e assicurarsi che:

  • I dati mobili non superano le dimensioni massime (vedere Roaming Archiviazione Quota per informazioni dettagliate).
  • I file vengono chiusi e rilasciati correttamente.
  • Esistono almeno due dispositivi che eseguono la stessa versione dell'app.

Registrarsi per ricevere una notifica quando vengono modificati i dati mobili

Vedere la nota importante sul roaming dei dati.

Per usare i dati mobili dell'app, è necessario registrarsi per le modifiche ai dati mobili e recuperare i contenitori di dati mobili in modo da poter leggere e scrivere le impostazioni.

  1. Registrarsi per ricevere una notifica quando vengono modificati i dati mobili.

    L'evento DataChanged invia una notifica quando cambiano i dati mobili. In questo esempio viene impostato DataChangeHandler come gestore per le modifiche ai dati mobili.

void InitHandlers()
    {
       Windows.Storage.ApplicationData.Current.DataChanged += 
          new TypedEventHandler<ApplicationData, object>(DataChangeHandler);
    }

    void DataChangeHandler(Windows.Storage.ApplicationData appData, object o)
    {
       // TODO: Refresh your data
    }

  1. Ottenere i contenitori per le impostazioni e i file dell'app.

    Utilizzare la proprietà ApplicationData.RoamingSettings per ottenere le impostazioni e la proprietà ApplicationData.RoamingFolder per ottenere i file.

Windows.Storage.ApplicationDataContainer roamingSettings = 
        Windows.Storage.ApplicationData.Current.RoamingSettings;
    Windows.Storage.StorageFolder roamingFolder = 
        Windows.Storage.ApplicationData.Current.RoamingFolder;

Creare e recuperare le impostazioni di roaming

Vedere la nota importante sul roaming dei dati.

Usare la proprietà ApplicationDataContainer.Values per accedere alle impostazioni nel roamingSettings contenitore ottenuto nella sezione precedente. In questo esempio viene creata una semplice impostazione denominata exampleSetting e un valore composito denominato composite.

// Simple setting

roamingSettings.Values["exampleSetting"] = "Hello World";
// High Priority setting, for example, last page position in book reader app
roamingSettings.values["HighPriority"] = "65";

// Composite setting

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

roamingSettings.Values["exampleCompositeSetting"] = composite;

In questo esempio vengono recuperate le impostazioni appena create.

// Simple setting

Object value = roamingSettings.Values["exampleSetting"];

// Composite setting

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

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

Creare e recuperare file mobili

Vedere la nota importante sul roaming dei dati.

Per creare e aggiornare un file nell'archivio roaming dati dell'app, usare le API file, ad esempio Windows.Storage.StorageFolder.CreateFileAsync e Windows.Storage.FileIO.WriteTextAsync. Questo esempio crea un file denominato dataFile.txt nel roamingFolder contenitore e scrive la data e l'ora correnti nel file. Il valore ReplaceExisting dell'enumerazione 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 roamingFolder.CreateFileAsync("dataFile.txt", 
       CreationCollisionOption.ReplaceExisting);
   await FileIO.WriteTextAsync(sampleFile, formatter.Format(DateTimeOffset.Now));
}

Per aprire e leggere un file nell'archivio dati dell'app mobile, usare le API file, ad esempio Windows.Archiviazione. Archiviazione Folder.GetFileAsync, Windows.Archiviazione. Archiviazione File.GetFileFromApplicationUriAsync e Windows.Archiviazione. FileIO.ReadTextAsync. Questo esempio apre il dataFile.txt file creato nella sezione 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 roamingFolder.GetFileAsync("dataFile.txt");
      String timestamp = await FileIO.ReadTextAsync(sampleFile);
      // Data is contained in timestamp
   }
   catch (Exception)
   {
      // Timestamp not found
   }
}

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 locale, usare le API file, ad esempio Windows.Archiviazione. Archiviazione Folder.CreateFileAsync e Windows.Archiviazione. 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 dell'enumerazione 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 mobile, usare le API file, ad esempio Windows.Storage.StorageFolder.GetFileAsync, Windows.Storage.StorageFile.GetFileFromApplicationUriAsync, and 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 oggetti 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 32 livelli profondi.

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 ApplicationDataContainer Impostazioni. Metodo 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

Facoltativamente, è possibile versione dei dati dell'app per l'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 laproprietà Application.Version e il metodo ApplicationData.SetVersionAsync.