Added support for the LocalCacheFolder to validate extensibility of AppDataStorageHelper

Author: shweaver-MSFT

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

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Toolkit.Helpers;
+using Windows.Storage;
+
+namespace Microsoft.Toolkit.Uwp.Helpers
+{
+    /// <summary>
+    /// An extension of ApplicationDataStorageHelper with additional features for interop with the LocalCacheFolder.
+    /// </summary>
+    public partial class ApplicationDataStorageHelper
+    {
+        /// <summary>
+        ///  Gets the storage folder.
+        /// </summary>
+        public StorageFolder CacheFolder => AppData.LocalCacheFolder;
+
+        /// <summary>
+        /// Determines if a directory item already exists in the LocalCacheFolder.
+        /// </summary>
+        /// <param name="itemName">Key of the file.</param>
+        /// <returns>True if an item exists.</returns>
+        public Task<bool> CacheItemExistsAsync(string itemName)
+        {
+            return ItemExistsAsync(CacheFolder, itemName);
+        }
+
+        /// <summary>
+        /// Retrieves an object from a file in the LocalCacheFolder.
+        /// </summary>
+        /// <typeparam name="T">Type of object retrieved.</typeparam>
+        /// <param name="filePath">Path to the file that contains the object.</param>
+        /// <param name="default">Default value of the object.</param>
+        /// <returns>Waiting task until completion with the object in the file.</returns>
+        public Task<T> ReadCacheFileAsync<T>(string filePath, T @default = default)
+        {
+            return ReadFileAsync<T>(CacheFolder, filePath, @default);
+        }
+
+
+        /// <summary>
+        /// Retrieves the listings for a folder and the item types in the LocalCacheFolder.
+        /// </summary>
+        /// <param name="folderPath">The path to the target folder.</param>
+        /// <returns>A list of file types and names in the target folder.</returns>
+        public Task<IList<Tuple<DirectoryItemType, string>>> ReadCacheFolderAsync(string folderPath)
+        {
+            return ReadFolderAsync(CacheFolder, folderPath);
+        }
+
+        /// <summary>
+        /// Saves an object inside a file in the LocalCacheFolder.
+        /// </summary>
+        /// <typeparam name="T">Type of object saved.</typeparam>
+        /// <param name="filePath">Path to the file that will contain the object.</param>
+        /// <param name="value">Object to save.</param>
+        /// <returns>Waiting task until completion.</returns>
+        public Task CreateCacheFileAsync<T>(string filePath, T value)
+        {
+            return SaveFileAsync<T>(CacheFolder, filePath, value);
+        }
+
+        /// <summary>
+        /// Ensure a folder exists at the folder path specified in the LocalCacheFolder.
+        /// </summary>
+        /// <param name="folderPath">The path and name of the target folder.</param>
+        /// <returns>Waiting task until completion.</returns>
+        public Task CreateCacheFolderAsync(string folderPath)
+        {
+            return CreateFolderAsync(CacheFolder, folderPath);
+        }
+
+        /// <summary>
+        /// Deletes a file or folder item in the LocalCacheFolder.
+        /// </summary>
+        /// <param name="itemPath">The path to the item for deletion.</param>
+        /// <returns>Waiting task until completion.</returns>
+        public Task DeleteCacheItemAsync(string itemPath)
+        {
+            return DeleteItemAsync(CacheFolder, itemPath);
+        }
+    }
+}

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

@@ -15,7 +15,7 @@ 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
+    public partial class ApplicationDataStorageHelper : IFileStorageHelper, ISettingsStorageHelper
     {
         /// <summary>
         /// Get a new instance using ApplicationData.Current and the provided serializer.
@@ -43,11 +43,17 @@ public static async Task<ApplicationDataStorageHelper> GetForUserAsync(User user
         /// <summary>
         /// Gets the settings container.
         /// </summary>
-        protected ApplicationData AppData { get; private set; }
+        public ApplicationDataContainer Settings => AppData.LocalSettings;
 
-        private ApplicationDataContainer DefaultSettings => AppData.LocalSettings;
+        /// <summary>
+        ///  Gets the storage folder.
+        /// </summary>
+        public StorageFolder Folder => AppData.LocalFolder;
 
-        private StorageFolder DefaultFolder => AppData.LocalFolder;
+        /// <summary>
+        /// Gets the storage host.
+        /// </summary>
+        protected ApplicationData AppData { get; private set; }
 
         private readonly Toolkit.Helpers.IObjectSerializer _serializer;
 
@@ -65,15 +71,15 @@ public ApplicationDataStorageHelper(ApplicationData appData, Toolkit.Helpers.IOb
         /// <inheritdoc />
         public bool KeyExists(string key)
         {
-            return DefaultSettings.Values.ContainsKey(key);
+            return Settings.Values.ContainsKey(key);
         }
 
         /// <inheritdoc />
         public bool KeyExists(string compositeKey, string key)
         {
             if (KeyExists(compositeKey))
             {
-                ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)DefaultSettings.Values[compositeKey];
+                ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)Settings.Values[compositeKey];
                 if (composite != null)
                 {
                     return composite.ContainsKey(key);
@@ -86,7 +92,7 @@ public bool KeyExists(string compositeKey, string key)
         /// <inheritdoc />
         public T Read<T>(string key, T @default = default)
         {
-            if (!DefaultSettings.Values.TryGetValue(key, out var value) || value == null)
+            if (!Settings.Values.TryGetValue(key, out var value) || value == null)
             {
                 return @default;
             }
@@ -97,7 +103,7 @@ public T Read<T>(string key, T @default = default)
         /// <inheritdoc />
         public T Read<T>(string compositeKey, string key, T @default = default)
         {
-            ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)DefaultSettings.Values[compositeKey];
+            ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)Settings.Values[compositeKey];
             if (composite != null)
             {
                 string value = (string)composite[key];
@@ -113,15 +119,15 @@ public T Read<T>(string compositeKey, string key, T @default = default)
         /// <inheritdoc />
         public void Save<T>(string key, T value)
         {
-            DefaultSettings.Values[key] = _serializer.Serialize(value);
+            Settings.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];
+                ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)Settings.Values[compositeKey];
 
                 foreach (KeyValuePair<string, T> setting in values)
                 {
@@ -143,60 +149,60 @@ public void Save<T>(string compositeKey, IDictionary<string, T> values)
                     composite.Add(setting.Key, _serializer.Serialize(setting.Value));
                 }
 
-                DefaultSettings.Values[compositeKey] = composite;
+                Settings.Values[compositeKey] = composite;
             }
         }
 
         /// <inheritdoc />
         public void Delete(string key)
         {
-            DefaultSettings.Values.Remove(key);
+            Settings.Values.Remove(key);
         }
 
         /// <inheritdoc />
         public void Delete(string compositeKey, string key)
         {
             if (KeyExists(compositeKey))
             {
-                ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)DefaultSettings.Values[compositeKey];
+                ApplicationDataCompositeValue composite = (ApplicationDataCompositeValue)Settings.Values[compositeKey];
                 composite.Remove(key);
             }
         }
 
         /// <inheritdoc />
         public Task<bool> ItemExistsAsync(string itemName)
         {
-            return ItemExistsAsync(DefaultFolder, itemName);
+            return ItemExistsAsync(Folder, itemName);
         }
 
         /// <inheritdoc />
         public Task<T> ReadFileAsync<T>(string filePath, T @default = default)
         {
-            return ReadFileAsync<T>(DefaultFolder, filePath, @default);
+            return ReadFileAsync<T>(Folder, filePath, @default);
         }
 
         /// <inheritdoc />
         public Task<IList<Tuple<DirectoryItemType, string>>> ReadFolderAsync(string folderPath)
         {
-            return ReadFolderAsync(DefaultFolder, folderPath);
+            return ReadFolderAsync(Folder, folderPath);
         }
 
         /// <inheritdoc />
         public Task CreateFileAsync<T>(string filePath, T value)
         {
-            return SaveFileAsync<T>(DefaultFolder, filePath, value);
+            return SaveFileAsync<T>(Folder, filePath, value);
         }
 
         /// <inheritdoc />
         public Task CreateFolderAsync(string folderPath)
         {
-            return CreateFolderAsync(DefaultFolder, folderPath);
+            return CreateFolderAsync(Folder, folderPath);
         }
 
         /// <inheritdoc />
         public Task DeleteItemAsync(string itemPath)
         {
-            return DeleteItemAsync(DefaultFolder, itemPath);
+            return DeleteItemAsync(Folder, itemPath);
         }
 
         /// <summary>
@@ -208,7 +214,7 @@ public Task DeleteItemAsync(string itemPath)
         /// <returns>A task with the result of the file query.</returns>
         public Task<bool> FileExistsAsync(string fileName, bool isRecursive = false)
         {
-            return FileExistsAsync(DefaultFolder, fileName, isRecursive);
+            return FileExistsAsync(Folder, fileName, isRecursive);
         }
 
         /// <summary>
@@ -220,7 +226,7 @@ public Task<bool> FileExistsAsync(string fileName, bool isRecursive = false)
         /// <returns>Waiting task until completion.</returns>
         public Task<StorageFile> SaveFileAsync<T>(string filePath, T value)
         {
-            return SaveFileAsync<T>(DefaultFolder, filePath, value);
+            return SaveFileAsync<T>(Folder, filePath, value);
         }
 
         private async Task<bool> ItemExistsAsync(StorageFolder folder, string itemName)