ApplicationData Classe

Definizione

Spazio dei nomi:

Windows.Storage

Fornisce l'accesso all'archivio dati dell'applicazione. I dati dell'applicazione sono costituiti da file e impostazioni locali, mobili o temporanei.

public ref class ApplicationData sealed : IClosable

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.MTA)]
class ApplicationData final : IClosable

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.MTA)]
public sealed class ApplicationData : System.IDisposable

Public NotInheritable Class ApplicationData
Implements IDisposable

Ereditarietà

Object Platform::Object IInspectable ApplicationData

Attributi

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Implementazioni

IClosable IDisposable

Requisiti Windows

Famiglia di dispositivi	Windows 10 (è stato introdotto in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (è stato introdotto in v1.0)

Esempio

Nell'esempio di codice seguente viene illustrato come leggere o scrivere in una cartella ApplicationData desiderata. In questo esempio viene usato LocalFolder, ma il codice può essere leggermente modificato per accedere a LocalCacheFolder, RoamingFolder, SharedLocalFolder o TemporaryFolder in base alla modalità di archiviazione dei dati. SharedLocalFolder ha alcune restrizioni e richiede autorizzazioni speciali per accedere, per altre informazioni, vedere SharedLocalFolder.

// This example code can be used to read or write to an ApplicationData folder of your choice.

// Change this to Windows.Storage.StorageFolder roamingFolder = Windows.Storage.ApplicationData.Current.RoamingFolder;
// to use the RoamingFolder instead, for example.
Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;

// Write data to a file
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(DateTime.Now));
}

// Read data from a file
async Task ReadTimestamp()
{
    try
    {
        StorageFile sampleFile = await localFolder.GetFileAsync("dataFile.txt");
        String timestamp = await FileIO.ReadTextAsync(sampleFile);
        // Data is contained in timestamp
    }
    catch (FileNotFoundException e)
    {
        // Cannot find file
    }
    catch (IOException e)
    {
        // Get information from the exception, then throw
        // the info to the parent method.
        if(e.Source != null)
        {
            Debug.WriteLine("IOException source: {0}", e.Source);
        }
        throw;
    }
}

#include <winrt/Windows.Globalization.h>
#include <winrt/Windows.Globalization.DateTimeFormatting.h>
#include <winrt/Windows.Storage.h>

using namespace winrt;
using namespace Windows::Foundation;
using namespace Windows::Storage;
using namespace Windows::UI::Xaml;

// This example code can be used to read or write to an ApplicationData folder of your choice.

// Change this to StorageFolder m_localFolder{ Windows::Storage::ApplicationData::Current().RoamingFolder() }; to 
// use the RoamingFolder instead, for example.
StorageFolder m_localFolder{ Windows::Storage::ApplicationData::Current().LocalFolder() };

// Write data to a file.
IAsyncAction MainPage::WriteTimestampAsync()
{
    StorageFile sampleFile{ co_await m_localFolder.CreateFileAsync(L"dataFile.txt", CreationCollisionOption::ReplaceExisting) };
    Windows::Globalization::Calendar calendar;
    auto now = calendar.GetDateTime();
    Windows::Globalization::DateTimeFormatting::DateTimeFormatter formatter{ L"longtime" };

    try
    {
        co_await FileIO::WriteTextAsync(sampleFile, formatter.Format(now));
    }
    catch (winrt::hresult_error const& /* ex */)
    {
        // Timestamp not written.
    }
}

// Read data from a file.
IAsyncAction MainPage::ReadTimestampAsync()
{
    StorageFile file{ co_await m_localFolder.GetFileAsync(L"dataFile.txt") };

    try
    {
        winrt::hstring timestamp{ co_await Windows::Storage::FileIO::ReadTextAsync(file) };
    }
    catch (winrt::hresult_error const& /* ex */)
    {
        // Timestamp not read.
    }
}

IAsyncAction MainPage::ClickHandler(IInspectable const&, RoutedEventArgs const&)
{
    myButton().Content(box_value(L"Clicked"));

    co_await WriteTimestampAsync();
    co_await ReadTimestampAsync();
}

// This example code can be used to read or write to an ApplicationData folder of your choice.

// Change this to StorageFolder^ roamingFolder = ApplicationData::Current->RoamingFolder; to 
// use the RoamingFolder instead, for example.
StorageFolder^ localFolder = ApplicationData::Current->LocalFolder;

// Write data to a file
void MainPage::WriteTimestamp()
{
   concurrency::task<StorageFile^> fileOperation = 
       localFolder->CreateFileAsync("dataFile.txt", CreationCollisionOption::ReplaceExisting);
   fileOperation.then([this](StorageFile^ sampleFile)
   {
      auto calendar = ref new Calendar;
      auto now = calendar->ToDateTime();
      auto formatter = ref new Windows::Globalization::DateTimeFormatting::DateTimeFormatter("longtime");

      return FileIO::WriteTextAsync(sampleFile, formatter->Format(now));
   }).then([this](task<void> previousOperation) {
      try {
         previousOperation.get();
      } catch (Platform::Exception^) {
         // Timestamp not written
      }
   });
}

// Read data from a file
void MainPage::ReadTimestamp()
{
   concurrency::task<StorageFile^> getFileOperation(localFolder->GetFileAsync("dataFile.txt"));
   getFileOperation.then([this](StorageFile^ file)
   {
      return FileIO::ReadTextAsync(file);
   }).then([this](concurrency::task<String^> previousOperation) {
      String^ timestamp;

      try {
         // Data is contained in timestamp
         timestamp = previousOperation.get();
      } catch (...) {
         // Timestamp not found
      }
   });
}

' This example code can be used to read or write to an ApplicationData folder of your choice.

' Change this to Dim roamingFolder As Windows.Storage.StorageFolder = Windows.Storage.ApplicationData.Current.RoamingFolder
' to use the RoamingFolder instead, for example.
Dim localFolder As Windows.Storage.StorageFolder = Windows.Storage.ApplicationData.Current.LocalFolder

' Write data to a file
Private Async Sub WriteTimestamp()
   Dim formatter As DateTimeFormatter = New DateTimeFormatter("longtime")

   Dim sampleFile As StorageFile = Await localFolder.CreateFileAsync("dataFile.txt", 
       CreationCollisionOption.ReplaceExisting)
   Await FileIO.WriteTextAsync(sampleFile, formatter.Format(DateTime.Now));
End Sub

' Read data from a file
Private Async Function ReadTimestamp() As Task
   Try
      Dim sampleFile As StorageFile = Await localFolder.GetFileAsync("dataFile.txt")
      Dim timestamp As string = Await FileIO.ReadTextAsync(sampleFile)
      ' Data is contained in timestamp
   Catch e1 As Exception
      ' Timestamp not found
   End Try
End Function

Per altri esempi e informazioni sulla lettura e la scrittura in un file, vedere Creare, scrivere e leggere un file.

Commenti

Tipi di dati dell'applicazione

ApplicationData fornisce archiviazione locale, roaming e temporanea per i dati delle app su base utente. Usare questa classe per mantenere i dati specifici dell'app tra sessioni, utenti e in più dispositivi.

ApplicationData non fornisce l'accesso ai file in un pacchetto dell'app. A tale scopo, usare Windows.ApplicationModel.Package.InstalledLocation.

ApplicationData.Current offre l'istanza di ApplicationData dell'app. Usare questa istanza per ottenere cartelle o impostazioni dell'app.

Le cartelle vengono usate per archiviare i dati delle app come file nel file system. Le impostazioni dell'app vengono archiviate in coppie chiave/valore che possono essere organizzate in per i set annidati. I dati delle impostazioni vengono salvati nel Registro di sistema di Windows.

Questi sono i tipi principali di dati dell'app:

• Locale: archiviato nel dispositivo, eseguito il backup nel cloud e persiste tra gli aggiornamenti
• LocalCache: dati persistenti presenti nel dispositivo corrente, non sottoposti a backup e persistenti in tutti gli aggiornamenti
• SharedLocal: persistente in tutti gli utenti dell'app
• Roaming: esiste in tutti i dispositivi in cui l'utente ha installato l'app
• Temporaneo: può essere eliminato dal sistema in qualsiasi momento

Uso delle cartelle dell'applicazione

LocalFolder persiste tra gli aggiornamenti e viene eseguito il backup nel cloud come parte del backup del dispositivo. In genere, questa cartella deve essere usata per i dati utente persi se non è stato eseguito il backup. Alcuni esempi di dati archiviati in LocalFolder sono:

• disegno utente per un'app di arte
• cronologia degli esercizi giornalieri per un'app per il fitness
• un elenco acquisti per un'app todo archiviando le informazioni in LocalFolder, l'utente non perderà i dati dopo aver reimpostato il dispositivo o passando a un nuovo dispositivo. Per altri tipi di dati locali facili da ricreare e non necessari per il backup e il ripristino, usare LocalCacheFolder o TemporaryFolder.

LocalCacheFolder e TemporaryFolder sono archiviati localmente e non vengono sottoposti a backup nel cloud. LocalCacheFolder è sotto controllo di tale app ed è persistente tra le sessioni dell'app. LocalCacheFolder deve essere usato per il contenuto generato nelle sessioni dell'app, ad esempio file memorizzati nella cache, log o token di autenticazione. TemporaryFolder non è garantito essere persistente tra sessioni e può essere eliminato dal sistema in qualsiasi momento.

RoamingFolder viene in genere usato per le preferenze utente e le personalizzazioni, i collegamenti e i file di dati di piccole dimensioni. Il contenuto di RoamingFolder si sposta tra i dispositivi e le istanze dell'app dell'utente. RoamingFolder non deve essere usato per grandi quantità di dati, dati specifici di un dispositivo o dati che si basano sulla sincronizzazione istantanea.

Un'altra cartella, SharedLocalFolder, è persistente tra gli account utente dell'app e deve essere usata per file di grandi dimensioni a cui accede più utenti. È necessaria una configurazione aggiuntiva per accedere a SharedLocalFolder. Per altre informazioni sull'accesso e l'uso di questa cartella, vedere SharedLocalFolder.

È possibile archiviare i dati dell'app in formati specifici dell'app e con versioni. Per altre informazioni, vedere Versione e SetVersionAsync.

Per altre informazioni sull'uso di queste API, vedere Archiviare e recuperare le impostazioni e altri dati dell'app.

Proprietà

Current	Fornisce l'accesso all'archivio dati dell'app associato al pacchetto dell'app.
LocalCacheFolder	Ottiene la cartella nell'archivio dati dell'app locale in cui è possibile salvare i file non inclusi nel backup e nel ripristino.
LocalFolder	Ottiene la cartella radice nell'archivio dati dell'app locale. Questa cartella viene eseguita il backup nel cloud.
LocalSettings	Ottiene il contenitore delle impostazioni dell'applicazione nell'archivio dati dell'app locale.
RoamingFolder	Ottiene la cartella radice nell'archivio dati dell'app roaming.
RoamingSettings	Ottiene il contenitore delle impostazioni dell'applicazione nell'archivio dati dell'app mobile.
RoamingStorageQuota	Ottiene la dimensione massima dei dati che possono essere sincronizzati nel cloud dall'archivio dati dell'app roaming.
SharedLocalFolder	Ottiene la cartella radice nell'archivio dati dell'app condivisa.
TemporaryFolder	Ottiene la cartella radice nell'archivio dati dell'app temporanea.
Version	Ottiene il numero di versione dei dati dell'applicazione nell'archivio dati dell'app.

Metodi

ClearAsync()	Rimuove tutti i dati dell'applicazione dagli archivi dati di app locali, mobili e temporanei. Nota Il metodo ClearAsync() rileva un errore se sono presenti handle di file aperti. È consigliabile chiudere tutti i file aperti prima di chiamare ClearAsync.
ClearAsync(ApplicationDataLocality)	Rimuove tutti i dati dell'applicazione dall'archivio dati dell'app specificato. Nota Il metodo ClearAsync(ApplicationDataLocality) rileva un errore se sono presenti handle di file aperti. È consigliabile chiudere tutti i file aperti prima di chiamare ClearAsync.
ClearPublisherCacheFolderAsync(String)	Cancella i file e le sottocartelle dalla sottocartella specificata della cartella di archiviazione condivisa per il server di pubblicazione dell'app corrente.
Close()	Nota Questo membro non viene implementato in C#.
Dispose()	Esegue attività definite dall'applicazione, come rilasciare o reimpostare risorse non gestite.
GetForUserAsync(User)	Metodo statico che restituisce ApplicationData per un utente.
GetPublisherCacheFolder(String)	Ottiene la sottocartella specificata della cartella di archiviazione condivisa per il server di pubblicazione dell'app corrente.
SetVersionAsync(UInt32, ApplicationDataSetVersionHandler)	Imposta il numero di versione dei dati dell'applicazione nell'archivio dati dell'app.
SignalDataChanged()	Invia un evento DataChanged a tutti i gestori eventi registrati.

Eventi

DataChanged

Si verifica quando i dati dell'applicazione mobili vengono sincronizzati.

Vedi anche

• ApplicationDataCompositeValue
• ApplicationDataContainer
• ApplicationDataContainerSettings
• Archiviare e recuperare le impostazioni e altri dati dell'app
• Linee guida per il roaming dei dati applicazione
• Linee guida per le impostazioni dell'app
• Esempio di impostazioni dell'applicazione (Windows 8.1, Windows Phone 8.1)
• Esempio di dati applicazione