ApplicationData Classe

Definizione

public ref class ApplicationData sealed

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

/// [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

[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

Public NotInheritable Class ApplicationData
Implements IDisposable

Ereditarietà

Object Platform::Object IInspectable ApplicationData

Attributi

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Implementazioni

IClosable IDisposable

Requisiti Windows

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à

Metodi

Eventi

Si applica a

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