ObjectStorage enhancements

Microsoft.Toolkit.Uwp.SampleApp/Controls/SampleAppMarkdownRenderer.cs

@@ -417,7 +417,7 @@ public string DesiredLang
         /// <summary>
         /// The Local Storage Helper.
         /// </summary>
-        private LocalObjectStorageHelper storage = new LocalObjectStorageHelper(new SystemSerializer());
+        private ApplicationDataStorageHelper storage = ApplicationDataStorageHelper.GetCurrent(new Toolkit.Helpers.SystemSerializer());
 
         /// <summary>
         /// DocFX note types and styling info, keyed by identifier.

Microsoft.Toolkit.Uwp.SampleApp/Models/Sample.cs

@@ -44,7 +44,7 @@ public class Sample
 
         public static async void EnsureCacheLatest()
         {
-            var settingsStorage = new LocalObjectStorageHelper(new SystemSerializer());
+            var settingsStorage = ApplicationDataStorageHelper.GetCurrent(new Toolkit.Helpers.SystemSerializer());
 
             var onlineDocsSHA = await GetDocsSHA();
             var cacheSHA = settingsStorage.Read<string>(_cacheSHAKey);

Microsoft.Toolkit.Uwp.SampleApp/Models/Samples.cs

@@ -21,7 +21,7 @@ public static class Samples
         private static SemaphoreSlim _semaphore = new SemaphoreSlim(1);
 
         private static LinkedList<Sample> _recentSamples;
-        private static LocalObjectStorageHelper _localObjectStorageHelper = new LocalObjectStorageHelper(new SystemSerializer());
+        private static ApplicationDataStorageHelper _localObjectStorageHelper = ApplicationDataStorageHelper.GetCurrent(new Toolkit.Helpers.SystemSerializer());
 
         public static async Task<SampleCategory> GetCategoryBySample(Sample sample)
         {

Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Object Storage/ObjectStorageCode.bind

@@ -1,25 +1,24 @@
-var localObjectStorageHelper = new LocalObjectStorageHelper();
-var roamingObjectStorageHelper = new RoamingObjectStorageHelper();
+ApplicationDataStorageHelper appDataStorageHelper = ApplicationDataStorageHelper.GetCurrent(new Toolkit.Helpers.SystemSerializer());
 
 // Read and Save with simple objects
 string keySimpleObject = "simple";
-string result = localObjectStorageHelper.Read<string>(keySimpleObject);
-localObjectStorageHelper.Save(keySimpleObject, 47);
+string result = appDataStorageHelper.Read<string>(keySimpleObject);
+appDataStorageHelper.Save(keySimpleObject, 47);
 
 // Read and Save with complex/large objects
-string keyLargeObject = "large";
-var result = localObjectStorageHelper.ReadFileAsync<MyLargeObject>(keyLargeObject);
+string complexObjectKey = "complexObject";
+var complexObject = await appDataStorageHelper.ReadFileAsync<MyLargeObject>(complexObjectKey);
 
-var o = new MyLargeObject
+var myComplexObject = new MyComplexObject()
 {
     ...
 };
-localObjectStorageHelper.SaveFileAsync(keySimpleObject, o);
+await appDataStorageHelper.SaveFileAsync(complexObjectKey, myComplexObject);
 
 // Complex object
-public class MyLargeObject
+public class MyComplexObject
 {
     public string MyContent { get; set; }
     public List<string> MyContents { get; set; }
-    public List<MyLargeObject> MyObjects { get; set; }
+    public List<MyComplexObject> MyObjects { get; set; }
 }

Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Object Storage/ObjectStoragePage.xaml.cs

@@ -2,14 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using Microsoft.Toolkit.Helpers;
 using Microsoft.Toolkit.Uwp.Helpers;
 using Windows.UI.Xaml;
 
 namespace Microsoft.Toolkit.Uwp.SampleApp.SamplePages
 {
     public sealed partial class ObjectStoragePage
     {
-        private readonly IObjectStorageHelper localStorageHelper = new LocalObjectStorageHelper(new SystemSerializer());
+        private readonly ISettingsStorageHelper localStorageHelper = ApplicationDataStorageHelper.GetCurrent(new Toolkit.Helpers.SystemSerializer());
 
         public ObjectStoragePage()
         {

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/ApplicationDataStorageHelper.cs

@@ -0,0 +1,236 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Toolkit.Helpers;
+using Windows.Storage;
+using Windows.System;
+
+namespace Microsoft.Toolkit.Uwp.Helpers
+{
+    /// <summary>
+    /// Storage helper for files and folders living in Windows.Storage.ApplicationData storage endpoints.
+    /// </summary>
+    public class ApplicationDataStorageHelper : IFileStorageHelper, ISettingsStorageHelper
+    {
+        /// <summary>
+        /// Get a new instance using ApplicationData.Current and the provided serializer.
+        /// </summary>
+        /// <param name="objectSerializer">Serializer for converting stored values.</param>
+        /// <returns>A new instance of ApplicationDataStorageHelper.</returns>
+        public static ApplicationDataStorageHelper GetCurrent(Toolkit.Helpers.IObjectSerializer objectSerializer)
+        {
+            var appData = ApplicationData.Current;
+            return new ApplicationDataStorageHelper(appData, objectSerializer);
+        }
+
+        /// <summary>
+        /// Get a new instance using the ApplicationData for the provided user and serializer.
+        /// </summary>
+        /// <param name="user">App data user owner.</param>
+        /// <param name="objectSerializer">Serializer for converting stored values.</param>
+        /// <returns>A new instance of ApplicationDataStorageHelper.</returns>
+        public static async Task<ApplicationDataStorageHelper> GetForUserAsync(User user, Toolkit.Helpers.IObjectSerializer objectSerializer)
+        {
+            var appData = await ApplicationData.GetForUserAsync(user);
+            return new ApplicationDataStorageHelper(appData, objectSerializer);
+        }
+
+        /// <summary>
+        /// Gets the settings container.
+        /// </summary>
+        protected ApplicationData AppData { get; private set; }
+
+        private ApplicationDataContainer DefaultSettings => AppData.LocalSettings;
+
+        private StorageFolder DefaultFolder => AppData.LocalFolder;
+
+        private readonly Toolkit.Helpers.IObjectSerializer _serializer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ApplicationDataStorageHelper"/> class.
+        /// </summary>
+        /// <param name="appData">The data store to interact with.</param>
+        /// <param name="objectSerializer">Serializer for converting stored values.</param>
+        public ApplicationDataStorageHelper(ApplicationData appData, Toolkit.Helpers.IObjectSerializer objectSerializer)
+        {
+            AppData = appData ?? throw new ArgumentNullException(nameof(appData));
+            _serializer = objectSerializer ?? throw new ArgumentNullException(nameof(objectSerializer));
+        }
+
+        /// <inheritdoc />
+        public bool KeyExists(string key)
+        {
+            return DefaultSettings.Values.ContainsKey(key);
+        }
+
+        /// <inheritdoc />
+        public bool KeyExists(string compositeKey, string key)
+        {
+            if (KeyExists(compositeKey))
+            {
+                ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)DefaultSettings.Values[compositeKey];
+                if (composite != null)
+                {
+                    return composite.ContainsKey(key);
+                }
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc />
+        public T Read<T>(string key, T @default = default)
+        {
+            if (!DefaultSettings.Values.TryGetValue(key, out var value) || value == null)
+            {
+                return @default;
+            }
+
+            return _serializer.Deserialize<T>(value);
+        }
+
+        /// <inheritdoc />
+        public T Read<T>(string compositeKey, string key, T @default = default)
+        {
+            ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)DefaultSettings.Values[compositeKey];
+            if (composite != null)
+            {
+                string value = (string)composite[key];
+                if (value != null)
+                {
+                    return _serializer.Deserialize<T>(value);
+                }
+            }
+
+            return @default;
+        }
+
+        /// <inheritdoc />
+        public void Save<T>(string key, T value)
+        {
+            DefaultSettings.Values[key] = _serializer.Serialize(value);
+        }
+
+        /// <inheritdoc />
+        public void Save<T>(string compositeKey, IDictionary<string, T> values)
+        {
+            if (KeyExists(compositeKey))
+            {
+                ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)DefaultSettings.Values[compositeKey];
+
+                foreach (KeyValuePair<string, T> setting in values)
+                {
+                    if (composite.ContainsKey(setting.Key))
+                    {
+                        composite[setting.Key] = _serializer.Serialize(setting.Value);
+                    }
+                    else
+                    {
+                        composite.Add(setting.Key, _serializer.Serialize(setting.Value));
+                    }
+                }
+            }
+            else
+            {
+                ApplicationDataCompositeValue composite = new ApplicationDataCompositeValue();
+                foreach (KeyValuePair<string, T> setting in values)
+                {
+                    composite.Add(setting.Key, _serializer.Serialize(setting.Value));
+                }
+
+                DefaultSettings.Values[compositeKey] = composite;
+            }
+        }
+
+        /// <inheritdoc />
+        public void Delete(string key)
+        {
+            DefaultSettings.Values.Remove(key);
+        }
+
+        /// <inheritdoc />
+        public void Delete(string compositeKey, string key)
+        {
+            if (KeyExists(compositeKey))
+            {
+                ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)DefaultSettings.Values[compositeKey];
+                composite.Remove(key);
+            }
+        }
+
+        /// <inheritdoc />
+        public Task<bool> FileExistsAsync(string filePath)
+        {
+            return FileExistsAsync(DefaultFolder, filePath);
+        }
+
+        /// <inheritdoc />
+        public Task<T> ReadFileAsync<T>(string filePath, T @default = default)
+        {
+            return ReadFileAsync<T>(DefaultFolder, filePath, @default);
+        }
+
+        /// <inheritdoc />
+        public Task<IList<string>> ReadFolderAsync(string folderPath)
+        {
+            return ReadFolderAsync(DefaultFolder, folderPath);
+        }
+
+        /// <inheritdoc />
+        public Task SaveFileAsync<T>(string filePath, T value)
+        {
+            return SaveFileAsync<T>(DefaultFolder, filePath, value);
+        }
+
+        /// <inheritdoc />
+        public Task SaveFolderAsync(string folderPath)
+        {
+            return SaveFolderAsync(DefaultFolder, folderPath);
+        }
+
+        /// <inheritdoc />
+        public Task DeleteItemAsync(string itemPath)
+        {
+            return DeleteItemAsync(DefaultFolder, itemPath);
+        }
+
+        private Task<bool> FileExistsAsync(StorageFolder folder, string filePath)
+        {
+            return folder.FileExistsAsync(filePath);
+        }
+
+        private async Task<T> ReadFileAsync<T>(StorageFolder folder, string filePath, T @default = default)
+        {
+            string value = await StorageFileHelper.ReadTextFromFileAsync(folder, filePath);
+            return (value != null) ? _serializer.Deserialize<T>(value) : @default;
+        }
+
+        private async Task<IList<string>> ReadFolderAsync(StorageFolder folder, string folderPath)
+        {
+            var targetFolder = await folder.GetFolderAsync(folderPath);
+            var files = await targetFolder.GetFilesAsync();
+            return files.Select((f) => f.Path + f.Name).ToList();
+        }
+
+        private Task SaveFileAsync<T>(StorageFolder folder, string filePath, T value)
+        {
+            return StorageFileHelper.WriteTextToFileAsync(folder, _serializer.Serialize(value)?.ToString(), filePath, CreationCollisionOption.ReplaceExisting);
+        }
+
+        private async Task SaveFolderAsync(StorageFolder folder, string folderPath)
+        {
+            await folder.CreateFolderAsync(folderPath, CreationCollisionOption.OpenIfExists);
+        }
+
+        private async Task DeleteItemAsync(StorageFolder folder, string itemPath)
+        {
+            var item = await folder.GetItemAsync(itemPath);
+            await item.DeleteAsync();
+        }
+    }
+}

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/BaseObjectStorageHelper.cs

@@ -12,6 +12,7 @@ namespace Microsoft.Toolkit.Uwp.Helpers
     /// <summary>
     /// Shared implementation of ObjectStorageHelper.
     /// </summary>
+    [Obsolete("BaseObjectStorageHelper is deprecated and has been superceded by ApplicationDataStorageHelper.")]
     public abstract class BaseObjectStorageHelper : IObjectStorageHelper
     {
         private readonly IObjectSerializer serializer;

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/IObjectSerializer.cs

@@ -2,11 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
+
 namespace Microsoft.Toolkit.Uwp.Helpers
 {
     /// <summary>
     /// A basic serialization service.
     /// </summary>
+    [Obsolete("IObjectSerializer has been migrated to the *.Toolikit package.")]
     public interface IObjectSerializer
     {
         /// <summary>

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/IObjectStorageHelper.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Windows.Storage;
@@ -11,6 +12,7 @@ namespace Microsoft.Toolkit.Uwp.Helpers
     /// <summary>
     /// Service used to store data.
     /// </summary>
+    [Obsolete("IObjectStorageHelper is deprecated. Please use IDictionaryStorageHelper and IFileStorageHelper interfaces instead.")]
     public interface IObjectStorageHelper
     {
         /// <summary>

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs

@@ -2,13 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using Windows.Storage;
 
 namespace Microsoft.Toolkit.Uwp.Helpers
 {
     /// <summary>
     /// Store data in the Local environment (only on the current device).
     /// </summary>
+    [Obsolete("LocalObjectStorageHelper is deprecated and has been superceded by the ApplicationDataStorageHelper.")]
     public class LocalObjectStorageHelper : BaseObjectStorageHelper
     {
         /// <summary>

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/SystemSerializer.cs

@@ -12,6 +12,7 @@ namespace Microsoft.Toolkit.Uwp.Helpers
     /// A bare-bones serializer which knows how to deal with primitive types and strings only. It will store them directly based on the <see cref="ApplicationDataContainer"/> API.
     /// It is recommended for more complex scenarios to implement your own <see cref="IObjectSerializer"/> based on System.Text.Json, Newtonsoft.Json, or DataContractJsonSerializer see https://aka.ms/wct/storagehelper-migration
     /// </summary>
+    [Obsolete("SystemSerializer has been migrated to the *.Toolikit package.")]
     public class SystemSerializer : IObjectSerializer
     {
         /// <summary>

Microsoft.Toolkit.Uwp/Helpers/SystemInformation.cs

@@ -23,9 +23,9 @@ namespace Microsoft.Toolkit.Uwp.Helpers
     public sealed class SystemInformation
     {
         /// <summary>
-        /// The <see cref="LocalObjectStorageHelper"/> instance used to save and retrieve application settings.
+        /// The <see cref="ApplicationDataStorageHelper"/> instance used to save and retrieve application settings.
         /// </summary>
-        private readonly LocalObjectStorageHelper _localObjectStorageHelper = new(new SystemSerializer());
+        private readonly ApplicationDataStorageHelper _localObjectStorageHelper = ApplicationDataStorageHelper.GetCurrent(new Toolkit.Helpers.SystemSerializer());
 
         /// <summary>
         /// The starting time of the current application session (since app launch or last move to foreground).