Partager via

Stocker et récupérer des paramètres et autres données d’application

  • Article

Les données d’application sont des données mutables créées et gérées par une application spécifique. Elles incluent l’état d’exécution, les paramètres de l’application, les préférences utilisateur, le contenu de référence (par exemple, les définitions du dictionnaire dans une application de dictionnaire), ainsi que d’autres paramètres. Les données d’application sont différentes des données utilisateur, les données que l’utilisateur crée et gère lors de l’utilisation d’une application. Les données utilisateur comprennent des fichiers multimédias, des transcriptions d’e-mail ou de communication, ou des enregistrements de base de données contenant le contenu créé par l’utilisateur. Les données de l’utilisateur peuvent être utiles ou significatives pour plus d’une application. Il s’agit souvent de données que l’utilisateur souhaite manipuler ou transmettre en tant qu’entité indépendante de l’application elle-même, comme un document.

Remarque importante concernant les données de l’application : la durée de vie des données de l’application est liée à la durée de vie de l’application. Si l’application est supprimée, toutes les données de l’application seront perdues. N’utilisez pas les données de l’application pour stocker les données de l’utilisateur ou tout ce que les utilisateurs pourraient considérer comme précieux et irremplaçable. Nous recommandons d’utiliser les bibliothèques de l’utilisateur et Microsoft OneDrive pour stocker ce type d’informations. Les données d’application sont idéales pour stocker les préférences, les paramètres et les favoris de l’utilisateur en fonction de l’application.

Type de données d’application

Il existe deux types de données d’application : les paramètres et les fichiers.

Paramètres

Utilisez les paramètres pour enregistrer les préférences de l’utilisateur et les informations sur l’état de l’application. L’API des données de l’application vous permet de créer et de récupérer facilement des paramètres (nous vous montrerons quelques exemples plus loin dans cet article).

Voici les types de données que vous pouvez utiliser pour les paramètres de l’application :

  • UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double
  • Booléen
  • Char16, Chaîne
  • DateTime, TimeSpan
  • GUID, Point, Taille, Rect
  • ApplicationDataCompositeValue : ensemble de paramètres d’application associés qui doivent être sérialisés et désérialisés de façon atomique. Utilisez des paramètres composites pour gérer facilement les mises à jour atomiques de paramètres interdépendants. Le système garantit l’intégrité des paramètres composites en cas d’accès simultané et d’itinérance. Les paramètres composites sont optimisés pour de petites quantités de données, et les performances peuvent être médiocres si vous les utilisez pour de grands jeux de données.

Fichiers

Utilisez des fichiers pour stocker des données binaires ou pour créer vos propres types sérialisés personnalisés.

Stockage des données de l’application dans les magasins de données de l’application

Lorsqu’une application est installée, le système lui attribue ses propres magasins de données par utilisateur pour les paramètres et les fichiers. Vous n’avez pas besoin de savoir où et comment ces données existent, car le système est chargé de gérer le stockage physique, en veillant à ce que les données soient isolées des autres applications et des autres utilisateurs. Le système préserve également le contenu de ces magasins de données lorsque l’utilisateur installe une mise à jour de votre application et supprime complètement et proprement le contenu de ces magasins de données lorsque votre application est désinstallée.

Dans son magasin de données, chaque application possède des répertoires racines définis par le système : un pour les fichiers locaux, un pour les fichiers itinérants et un pour les fichiers temporaires. Votre application peut ajouter de nouveaux fichiers et de nouveaux conteneurs à chacun de ces répertoires racines.

Données d’application locale

Les données d’application locales doivent être utilisées pour toutes les informations qui doivent être conservées entre les sessions d’application et ne conviennent pas aux données d’application itinérantes. Les données qui sont non applicables sur d’autres appareils doivent également être stockées ici. Il n’y a pas de restriction générale sur la taille des données locales stockées. Utilisez le magasin de données de l’application locale pour les données qu’il n’est pas judicieux de faire circuler et pour les grands jeux de données.

Récupérer le magasin de données de l’application locale

Avant de pouvoir lire ou écrire des données d’applications locales, vous devez récupérer le magasin de données d’applications locales. Pour récupérer le magasin de données de l’application locale, utilisez la propriété ApplicationData.LocalSettings pour obtenir les paramètres locaux de l’application sous la forme d’un objet ApplicationDataContainer. Utilisez la propriété ApplicationData.LocalFolder pour obtenir les fichiers d’un objet StorageFolder. Utilisez la propriété ApplicationData.LocalCacheFolder pour obtenir le dossier du magasin de données de l’application locale dans lequel vous pouvez enregistrer les fichiers qui ne sont pas inclus dans la sauvegarde et la restauration.

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

Créer et récupérer un paramètre local simple

Pour créer ou écrire un paramètre, utilisez la propriété ApplicationDataContainer.Values pour accéder aux paramètres du conteneur localSettings que nous avons obtenu à l’étape précédente. Cet exemple crée un paramètre nommé exampleSetting.

// Simple setting

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

Pour récupérer le paramètre, vous utilisez la même propriété ApplicationDataContainer.Values que celle utilisée pour créer le paramètre. Cet exemple montre comment récupérer le paramètre que nous venons de créer.

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

Créer et récupérer une valeur composite locale

Pour créer ou écrire une valeur composite, créez un objet ApplicationDataCompositeValue. Cet exemple crée un paramètre composite nommé exampleCompositeSetting et l’ajoute au conteneur localSettings.

// Composite setting

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

localSettings.Values["exampleCompositeSetting"] = composite;

Cet exemple montre comment récupérer la valeur composite que nous venons de créer.

// 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"]
}

Créer et écrire un fichier local

Pour créer et mettre à jour un fichier dans le magasin de données de l’application locale, utilisez les API de fichiers, telles que Windows.Storage.StorageFolder.CreateFileAsync et Windows.Storage.FileIO.WriteTextAsync. Cet exemple crée un fichier nommé dataFile.txt dans le conteneur localFolder et y écrit la date et l’heure actuelles. La valeur ReplaceExisting de l’énumération CreationCollisionOption indique qu’il faut remplacer le fichier s’il existe déjà.

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));
}

Pour ouvrir et lire un fichier dans le magasin de données de l’application locale, utilisez les API de fichiers, telles que Windows.Storage.StorageFolder.GetFileAsync, Windows.Storage.StorageFile.GetFileFromApplicationUriAsync et Windows.Storage.FileIO.ReadTextAsync. Cet exemple ouvre le fichier dataFile.txt créé à l’étape précédente et lit la date dans le fichier. Pour en savoir plus sur le fichier de chargement des ressources à partir de différents emplacements, reportez-vous à Comment charger des ressources de fichier.

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
   }
}

Données en itinérance

Avertissement

Les données et paramètres d’itinérance ne sont plus pris en charge depuis Windows 11. En remplacement, il est recommandé d’utiliser Azure App Service. Azure App Service est largement pris en charge, bien documenté, fiable et prend en charge les scénarios interplateformes/inter-écosystèmes comme iOS, Android et le web.

La documentation suivante s’applique aux versions 1909 et inférieures de Windows 10.

Si vous utilisez des données itinérantes dans votre application, vos utilisateurs peuvent facilement synchroniser les données de votre application sur plusieurs appareils. Si un utilisateur installe votre application sur plusieurs appareils, le système d’exploitation synchronise les données de l’application, ce qui réduit la quantité de travail de configuration que l’utilisateur doit effectuer pour votre application sur son deuxième appareil. L’itinérance permet également à vos utilisateurs de poursuivre une tâche, telle que la composition d’une liste, là où ils se sont arrêtés, même sur un autre appareil. Le système d’exploitation réplique les données d’itinérance vers le nuage lorsqu’elles sont mises à jour et les synchronise avec les autres appareils sur lesquels l’application est installée.

Le système d’exploitation limite la taille des données d’application que chaque application peut parcourir. Reportez-vous à ApplicationData.Roaming Stockage Quota. Si l’application atteint cette limite, aucune donnée de l’application ne sera répliquée dans le nuage jusqu’à ce que le total des données de l’application en itinérance soit à nouveau inférieur à la limite. C’est pourquoi une meilleure pratique consiste à n’utiliser les données itinérantes que pour les préférences de l’utilisateur, les liens et les petits fichiers de données.

Les données d’itinérance d’une application sont disponibles dans le nuage tant que l’utilisateur y accède à partir d’un appareil dans l’intervalle de temps requis. Si l’utilisateur n’utilise pas une application pendant plus longtemps que cet intervalle de temps, ses données d’itinérance sont supprimées du cloud. Si un utilisateur désinstalle une application, ses données itinérantes ne sont pas automatiquement supprimées du cloud, elles sont conservées. Si l’utilisateur réinstalle l’application dans l’intervalle de temps, les données d’itinérance sont synchronisées à partir du cloud.

Ce qu’il faut faire et ne pas faire en matière de données en itinérance

Consultez la note importante concernant les données itinérantes.

  • L’itinérance est utilisée pour les préférences et les personnalisations de l’utilisateur, les liens et les petits fichiers de données. Par exemple, l’itinérance permet de conserver la couleur d’arrière-plan préférée d’un utilisateur sur tous les appareils.
  • Utilisez l’itinérance pour permettre aux utilisateurs de poursuivre une tâche sur plusieurs appareils. Par exemple, parcourez les données d’application telles que le contenu d’un e-mail brouillon ou la page la plus récemment consultée dans une application de lecture.
  • Gérer l’événement DataChanged en mettant à jour les données de l’application. Cet événement se produit lorsque les données de l’application viennent d’être synchronisées à partir du cloud.
  • Faire référence au contenu plutôt qu’aux données brutes. Par exemple, parcourir une URL plutôt que le contenu d’un article en ligne.
  • Pour les paramètres importants et critiques, utilisez le paramètre HighPriority associé à RoamingSettings.
  • Les données d’application spécifiques à un appareil ne sont pas utilisées en itinérance. Certaines informations ne sont pertinentes que localement, comme le chemin d’accès à une ressource de fichier local. Si vous décidez de transférer des informations locales, assurez-vous que l’application peut les récupérer si elles ne sont pas valides sur l’appareil secondaire.
  • Ne parcourez pas de grands ensembles de données d’application. Il y a une limite à la quantité de données d’application qu’une application peut utiliser en itinérance. Utilisez la propriété RoamingStorageQuota pour obtenir ce maximum. Si une application atteint cette limite, aucune donnée ne peut circuler jusqu’à ce que la taille du magasin de données de l’application ne dépasse plus la limite. Lorsque vous concevez votre application, réfléchissez à la manière de limiter les données volumineuses afin de ne pas dépasser la limite. Par exemple, si l’enregistrement de l’état d’un jeu nécessite 10 Ko chacun, l’application pourrait ne permettre à l’utilisateur de stocker que 10 jeux au maximum.
  • N’utilisez pas l’itinérance pour les données qui dépendent d’une synchronisation instantanée. Windows ne garantit pas une synchronisation instantanée. L’itinérance peut être considérablement retardée si un utilisateur est hors ligne ou sur un réseau à forte latence. Veillez à ce que votre interface utilisateur ne dépende pas d’une synchronisation instantanée.
  • N’utilisez pas l’itinérance pour les données qui changent souvent. Par exemple, si votre application enregistre des informations qui changent fréquemment, comme la position dans une chanson à la seconde près, ne les stockez pas en tant que données d’application itinérantes. Choisissez plutôt une représentation moins fréquente qui offre une bonne expérience utilisateur, comme la chanson en cours de lecture.

Conditions préalables à l’itinérance

Consultez la note importante concernant les données itinérantes.

Tout utilisateur peut bénéficier des données d’application itinérantes s’il utilise un compte Microsoft pour se connecter à son appareil. Toutefois, les utilisateurs et les administrateurs de stratégies de groupe peuvent à tout moment désactiver les données des applications itinérantes sur un appareil. Si un utilisateur décide de ne pas utiliser un compte Microsoft ou s’il désactive les fonctionnalités d’itinérance des données, il peut continuer à se servir de votre application. Toutefois, les données d’application sont gérées de manière locale sur chaque appareil.

Les données stockées dans PasswordVault sont transférées uniquement si un utilisateur a « approuvé » un appareil. Si un appareil n’est pas fiable, les données sécurisées dans ce coffre-fort ne circuleront pas.

Résolution de conflits

Consultez la note importante concernant les données itinérantes.

Les données de l’application en itinérance ne sont pas destinées à être utilisées simultanément sur plusieurs appareils. Si un conflit survient lors de la synchronisation parce qu’une unité de données particulière a été modifiée sur deux appareils, le système favorisera toujours la valeur qui a été écrite en dernier. Cette mesure garantit que l’application utilise les informations les plus récentes. Si l’unité de données est un composite de réglage, la résolution de conflits se fera toujours au niveau de l’unité de réglage, ce qui signifie que le composite ayant subi la dernière modification sera synchronisé.

Quand écrire des données

Consultez la note importante concernant les données itinérantes.

En fonction de la durée de vie prévue du réglage, les données doivent être écrites à différents moments. Les données de l’application qui changent rarement ou lentement doivent être écrites immédiatement. Cependant, les données de l’application qui changent fréquemment ne doivent être écrites que périodiquement, à intervalles réguliers (par exemple toutes les 5 minutes), ainsi que lorsque l’application est suspendue. Par exemple, une application de musique peut écrire le paramètre « chanson actuelle » au début de chaque nouvelle chanson, mais la position réelle dans la chanson doit être écrite uniquement au moment de l’interruption.

Protection contre l’utilisation excessive

Consultez la note importante concernant les données itinérantes.

Le système dispose de divers mécanismes de protection pour éviter l’utilisation inappropriée des ressources. Si les données de l’application ne sont pas transférées comme prévu, il est probable que l’appareil ait été temporairement restreint. Le fait d’attendre un certain temps résout généralement cette situation automatiquement et aucune action n’est nécessaire.

Contrôle de version

Consultez la note importante concernant les données itinérantes.

Les données d’application peuvent utiliser le versionnage pour changer de niveau de structure de données. Le numéro de version est différent de la version de l’application et peut être défini à volonté. Bien que cela ne soit pas obligatoire, il est fortement recommandé d’utiliser des numéros de version croissants, car des complications indésirables (y compris la perte de données) pourraient survenir si vous essayez de passer à un numéro de version de données inférieur qui représente des données plus récentes.

Les données d’application ne circulent qu’entre les applications installées ayant le même numéro de version. Par exemple, les appareils de la version 2 transféreront des données entre eux et les appareils de la version 3 feront de même, mais il n’y aura pas d’itinérance entre un appareil fonctionnant avec la version 2 et un appareil fonctionnant avec la version 3. Si vous installez une nouvelle application qui a utilisé différents numéros de version sur d’autres appareils, l’application nouvellement installée synchronisera les données de l’application associées au numéro de version le plus élevé.

Tests et outils

Consultez la note importante concernant les données itinérantes.

Les développeurs peuvent verrouiller leur appareil afin de déclencher une synchronisation des données des applications itinérantes. Si vous avez l’impression que les données de l’application ne sont pas transférées dans un certain délai d’exécution, vérifiez les éléments suivants et assurez-vous qu’ils sont corrects :

  • Vos données d’itinérance ne dépassent pas la taille maximale (reportez-vous à Roaming Stockage Quota pour en savoir plus).
  • Vos dossiers sont clôturés et libérés correctement.
  • Il existe au moins deux appareils exécutant la même version de l’application.

S’inscrire pour recevoir une notification en cas de modification des données d’itinérance

Consultez la note importante concernant les données itinérantes.

Pour utiliser les données de l’application itinérante, vous devez vous inscrire aux modifications des données d’itinérance et récupérer les conteneurs de données d’itinérance afin de pouvoir lire et écrire les paramètres.

  1. Inscrivez-vous pour recevoir une notification en cas de modification des données d’itinérance.

    L’événement DataChanged vous avertit lorsque les données d’itinérance changent. Cet exemple définit DataChangeHandler comme gestionnaire des modifications des données d’itinérance.

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. Obtenez les conteneurs pour les paramètres et les fichiers de l’application.

    Utilisez la propriété ApplicationData.RoamingSettings pour obtenir les paramètres et la propriété ApplicationData.RoamingFolder pour obtenir les fichiers.

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

Créer et récupérer des paramètres d’itinérance

Consultez la note importante concernant les données itinérantes.

Utilisez la propriété ApplicationDataContainer.Values pour accéder aux paramètres du conteneur roamingSettings que nous avons obtenu dans la section précédente. Cet exemple crée un paramètre simple nommé exampleSetting et une valeur composite nommée 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;

Cet exemple permet de récupérer les paramètres que nous venons de créer.

// 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"]
}

Créer et récupérer des fichiers itinérants

Consultez la note importante concernant les données itinérantes.

Pour créer et mettre à jour un fichier dans le magasin de données de l’application d’itinérance, utilisez les API de fichiers, telles que Windows.Storage.StorageFolder.CreateFileAsync et Windows.Storage.FileIO.WriteTextAsync. Cet exemple crée un fichier nommé dataFile.txt dans le conteneur roamingFolder et y écrit la date et l’heure actuelles. La valeur ReplaceExisting de l’énumération CreationCollisionOption indique qu’il faut remplacer le fichier s’il existe déjà.

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));
}

Pour ouvrir et lire un fichier dans le magasin de données de l’application d’itinérance, utilisez les API de fichiers, telles que Windows.Storage.StorageFolder.GetFileAsync, Windows.Storage.StorageFile.GetFileFromApplicationUriAsync et Windows.Storage.FileIO.ReadTextAsync. Cet exemple ouvre le fichier dataFile.txt créé à la section précédente et lit la date dans le fichier. Pour en savoir plus sur le fichier de chargement des ressources à partir de différents emplacements, reportez-vous à Comment charger des ressources de fichier.

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
   }
}

Données d’applications temporaires

Le magasin de données temporaires de l’application fonctionne comme un cache. Ses fichiers ne se déplacent pas et peuvent être supprimés à tout moment. La tâche maintenance du système peut supprimer automatiquement les données stockées à cet emplacement à tout moment. L’utilisateur peut également effacer des fichiers du magasin de données temporaire à l’aide de Disk Cleanup. Les données temporaires de l’application peuvent être utilisées pour stocker des informations temporaires au cours d’une session de l’application. Il n’existe aucune garantie que ces données persistent au-delà de la fin de la session de l’application, car le système peut récupérer l’espace utilisé si nécessaire. L’emplacement est disponible à partir de la propriété temporaryFolder.

Récupérer le conteneur de données temporaire

Utilisez la propriété ApplicationData.TemporaryFolder pour obtenir les fichiers. Les étapes suivantes utilisent la variable temporaryFolder de cette étape.

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

Créer et lire des fichiers temporaires

Pour créer et mettre à jour un fichier dans le magasin de données de l’application temporaire, utilisez les API de fichiers, telles que Windows.Storage.StorageFolder.CreateFileAsync et Windows.Storage.FileIO.WriteTextAsync. Cet exemple crée un fichier nommé dataFile.txt dans le conteneur temporaryFolder et y écrit la date et l’heure actuelles. La valeur ReplaceExisting de l’énumération CreationCollisionOption indique qu’il faut remplacer le fichier s’il existe déjà.

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));
}

Pour ouvrir et lire un fichier dans le magasin de données de l’application temporaire, utilisez les API de fichiers, telles que Windows.Storage.StorageFolder.GetFileAsync, Windows.Storage.StorageFile.GetFileFromApplicationUriAsync et Windows.Storage.FileIO.ReadTextAsync. Cet exemple ouvre le fichier dataFile.txt créé à l’étape précédente et lit la date dans le fichier. Pour en savoir plus sur le fichier de chargement des ressources à partir de différents emplacements, reportez-vous à Comment charger des ressources de fichier.

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
   }
}

Organiser les données de l’application avec des conteneurs

Pour vous aider à organiser les paramètres et les fichiers de données de votre application, vous créez des conteneurs (représentés par des objets ApplicationDataContainer) au lieu de travailler directement avec des répertoires. Vous pouvez ajouter des conteneurs aux magasins de données locaux, itinérants et temporaires. Les conteneurs peuvent être imbriqués jusqu’à 32 niveaux de profondeur.

Pour créer un conteneur de paramètres, appelez la méthode ApplicationDataContainer.CreateContainer. Cet exemple crée un conteneur de paramètres locaux nommé exampleContainer et ajoute un paramètre nommé exampleSetting. La valeur Always de l’énumération ApplicationDataCreateDisposition indique que le conteneur est créé s’il n’existe pas déjà.

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";
}

Supprimer les paramètres de l’application et les conteneurs

Pour supprimer un paramètre simple dont votre application n’a plus besoin, utilisez la méthode ApplicationDataContainerSettings.Remove. Cet exemple supprime le paramètre local exampleSetting que nous avons créé précédemment.

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");

Pour supprimer un paramètre composite, utilisez la méthode ApplicationDataCompositeValue.Remove. Cet exemple supprime le paramètre composite local exampleCompositeSetting que nous avons créé dans un exemple précédent.

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");

Pour supprimer un conteneur, appelez la méthode ApplicationDataContainer.DeleteContainer. Cet exemple supprime le conteneur de paramètres locaux exampleContainer que nous avons créé précédemment.

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

// Delete container

localSettings.DeleteContainer("exampleContainer");

Contrôle de version de vos données d’application

Vous pouvez optionnellement versionner les données de votre application. Vous pourrez ainsi créer une future version de votre application qui changerait le format de ses données sans causer de problèmes de compatibilité avec la version précédente de votre application. L’application vérifie la version des données de l’application dans le magasin de données, et si la version est inférieure à la version attendue par l’application, celle-ci doit mettre à jour les données de l’application au nouveau format et mettre à jour la version. Pour en savoir plus, reportez-vous à la propriété Application.Version et la méthode ApplicationData.SetVersionAsync.