Created a SystemSerializer to handle our primitive types within SystemInformation

Tested copying data from 6.1 Sample App and was able to read/resume file writes with this new serializer.
TODO: Update tests.

Author: michael-hawker

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

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

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

@@ -39,7 +39,7 @@ public class Sample
 
         public static async void EnsureCacheLatest()
         {
-            var settingsStorage = new LocalObjectStorageHelper();
+            var settingsStorage = new LocalObjectStorageHelper(new 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 RoamingObjectStorageHelper _roamingObjectStorageHelper = new RoamingObjectStorageHelper();
+        private static LocalObjectStorageHelper _localObjectStorageHelper = new LocalObjectStorageHelper(new SystemSerializer());
 
         public static async Task<SampleCategory> GetCategoryBySample(Sample sample)
         {
@@ -98,7 +98,7 @@ public static async Task<LinkedList<Sample>> GetRecentSamples()
             if (_recentSamples == null)
             {
                 _recentSamples = new LinkedList<Sample>();
-                var savedSamples = _roamingObjectStorageHelper.Read<string>(_recentSamplesStorageKey);
+                var savedSamples = _localObjectStorageHelper.Read<string>(_recentSamplesStorageKey);
 
                 if (savedSamples != null)
                 {
@@ -144,7 +144,7 @@ private static void SaveRecentSamples()
             }
 
             var str = string.Join(";", _recentSamples.Take(10).Select(s => s.Name).ToArray());
-            _roamingObjectStorageHelper.Save<string>(_recentSamplesStorageKey, str);
+            _localObjectStorageHelper.Save<string>(_recentSamplesStorageKey, str);
         }
     }
 }

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

@@ -1,26 +1,33 @@
-<Page
-    x:Class="Microsoft.Toolkit.Uwp.SampleApp.SamplePages.ObjectStoragePage"
-    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    mc:Ignorable="d">
+<Page x:Class="Microsoft.Toolkit.Uwp.SampleApp.SamplePages.ObjectStoragePage"
+      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+      mc:Ignorable="d">
 
     <ScrollViewer>
         <StackPanel Margin="20">
-            <ToggleSwitch x:Name="StorageModeToggle" HorizontalAlignment="Center" 
-                          OnContent="Roaming storage (save across all your devices)"
-                          OffContent="Local storage (save on this device only)" />
+            <TextBox x:Name="KeyTextBox"
+                     Margin="0,10,0,0"
+                     PlaceholderText="Key" />
 
-            <TextBox x:Name="KeyTextBox" PlaceholderText="Key" Margin="0 10 0 0" />
+            <TextBox x:Name="ContentTextBox"
+                     Margin="0,10,0,0"
+                     PlaceholderText="Content to save" />
 
-            <TextBox x:Name="ContentTextBox" PlaceholderText="Content to save" Margin="0 10 0 0" />
-
-            <StackPanel Margin="0 10 0 0" Orientation="Horizontal" HorizontalAlignment="Center">
-                <Button x:Name="ReadButton" Content="Read from key" HorizontalAlignment="Center" Margin="5 0"
-                        Click="ReadButton_Click" />
-                <Button x:Name="SaveButton" Content="Save" HorizontalAlignment="Center" Margin="5 0"
-                        Click="SaveButton_Click" />
+            <StackPanel Margin="0,10,0,0"
+                        HorizontalAlignment="Center"
+                        Orientation="Horizontal">
+                <Button x:Name="ReadButton"
+                        Margin="5,0"
+                        HorizontalAlignment="Center"
+                        Click="ReadButton_Click"
+                        Content="Read from key" />
+                <Button x:Name="SaveButton"
+                        Margin="5,0"
+                        HorizontalAlignment="Center"
+                        Click="SaveButton_Click"
+                        Content="Save" />
             </StackPanel>
         </StackPanel>
     </ScrollViewer>

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

@@ -9,8 +9,7 @@ namespace Microsoft.Toolkit.Uwp.SampleApp.SamplePages
 {
     public sealed partial class ObjectStoragePage
     {
-        private readonly IObjectStorageHelper localStorageHelper = new LocalObjectStorageHelper();
-        private readonly IObjectStorageHelper roamingStorageHelper = new RoamingObjectStorageHelper();
+        private readonly IObjectStorageHelper localStorageHelper = new LocalObjectStorageHelper(new SystemSerializer());
 
         public ObjectStoragePage()
         {
@@ -24,21 +23,10 @@ private void ReadButton_Click(object sender, RoutedEventArgs e)
                 return;
             }
 
-            if (StorageModeToggle.IsOn)
+            // Read from local storage
+            if (localStorageHelper.KeyExists(KeyTextBox.Text))
             {
-                // Read from roaming storage
-                if (roamingStorageHelper.KeyExists(KeyTextBox.Text))
-                {
-                    ContentTextBox.Text = roamingStorageHelper.Read<string>(KeyTextBox.Text);
-                }
-            }
-            else
-            {
-                // Read from local storage
-                if (localStorageHelper.KeyExists(KeyTextBox.Text))
-                {
-                    ContentTextBox.Text = localStorageHelper.Read<string>(KeyTextBox.Text);
-                }
+                ContentTextBox.Text = localStorageHelper.Read<string>(KeyTextBox.Text);
             }
         }
 
@@ -54,16 +42,8 @@ private void SaveButton_Click(object sender, RoutedEventArgs e)
                 return;
             }
 
-            if (StorageModeToggle.IsOn)
-            {
-                // Save into roaming storage
-                roamingStorageHelper.Save(KeyTextBox.Text, ContentTextBox.Text);
-            }
-            else
-            {
-                // Save into local storage
-                localStorageHelper.Save(KeyTextBox.Text, ContentTextBox.Text);
-            }
+            // Save into local storage
+            localStorageHelper.Save(KeyTextBox.Text, ContentTextBox.Text);
         }
     }
 }

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

@@ -84,15 +84,7 @@ public bool KeyExists(string compositeKey, string key)
                 return @default;
             }
 
-            var type = typeof(T);
-            var typeInfo = type.GetTypeInfo();
-
-            if (typeInfo.IsPrimitive || type == typeof(string))
-            {
-                return (T)Convert.ChangeType(value, type);
-            }
-
-            return serializer.Deserialize<T>((string)value);
+            return serializer.Deserialize<T>(value);
         }
 
         /// <summary>
@@ -131,14 +123,7 @@ public void Save<T>(string key, T value)
             var type = typeof(T);
             var typeInfo = type.GetTypeInfo();
 
-            if (typeInfo.IsPrimitive || type == typeof(string))
-            {
-                Settings.Values[key] = value;
-            }
-            else
-            {
-                Settings.Values[key] = serializer.Serialize(value);
-            }
+            Settings.Values[key] = serializer.Serialize(value);
         }
 
         /// <summary>
@@ -213,7 +198,7 @@ public Task<bool> FileExistsAsync(string filePath)
         /// <returns>The <see cref="StorageFile"/> where the object was saved</returns>
         public Task<StorageFile> SaveFileAsync<T>(string filePath, T value)
         {
-            return StorageFileHelper.WriteTextToFileAsync(Folder, serializer.Serialize(value), filePath, CreationCollisionOption.ReplaceExisting);
+            return StorageFileHelper.WriteTextToFileAsync(Folder, serializer.Serialize(value)?.ToString(), filePath, CreationCollisionOption.ReplaceExisting);
         }
     }
 }

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

@@ -10,19 +10,19 @@ namespace Microsoft.Toolkit.Uwp.Helpers
     public interface IObjectSerializer
     {
         /// <summary>
-        /// Serialize an object into a string.
+        /// Serialize an object into a string. It is recommended to use strings as the final format for objects if you plan to use the <see cref="BaseObjectStorageHelper.SaveFileAsync{T}(string, T)"/> method.
         /// </summary>
         /// <typeparam name="T">The type of the object to serialize.</typeparam>
         /// <param name="value">The object to serialize.</param>
         /// <returns>The serialized object.</returns>
-        string Serialize<T>(T value);
+        object Serialize<T>(T value);
 
         /// <summary>
-        /// Deserialize a string into an object.
+        /// Deserialize a primitive or string into an object of the given type.
         /// </summary>
         /// <typeparam name="T">The type of the deserialized object.</typeparam>
         /// <param name="value">The string to deserialize.</param>
         /// <returns>The deserialized object.</returns>
-        T Deserialize<T>(string value);
+        T Deserialize<T>(object value);
     }
 }

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

@@ -16,7 +16,7 @@ public class LocalObjectStorageHelper : BaseObjectStorageHelper
         /// Initializes a new instance of the <see cref="LocalObjectStorageHelper"/> class,
         /// which can read and write data using the provided <see cref="IObjectSerializer"/>;
         /// In 6.1 and older the default Serializer was based on Newtonsoft.Json.
-        /// To implement a <see cref="IObjectSerializer"/> based on Newtonsoft.Json or System.Text.Json see https://aka.ms/wct/storagehelper-migration
+        /// To implement an <see cref="IObjectSerializer"/> based on System.Text.Json, Newtonsoft.Json, or DataContractJsonSerializer see https://aka.ms/wct/storagehelper-migration
         /// </summary>
         /// <param name="objectSerializer">The serializer to use.</param>
         public LocalObjectStorageHelper(IObjectSerializer objectSerializer)

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/RoamingObjectStorageHelper.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.Runtime.Serialization;
 using Windows.Storage;
 
@@ -10,13 +11,14 @@ namespace Microsoft.Toolkit.Uwp.Helpers
     /// <summary>
     /// Store data in the Roaming environment (shared across all user devices).
     /// </summary>
+    [Obsolete("Package State Roaming will be removed in a futures Windows Update, see https://docs.microsoft.com/windows/deployment/planning/windows-10-deprecated-features for more information.")]
     public class RoamingObjectStorageHelper : BaseObjectStorageHelper
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="RoamingObjectStorageHelper"/> class,
         /// which can read and write data using the provided <see cref="IObjectSerializer"/>;
         /// In 6.1 and older the default Serializer was based on Newtonsoft.Json.
-        /// To implement a <see cref="IObjectSerializer"/> based on Newtonsoft.Json or System.Text.Json see https://aka.ms/wct/storagehelper-migration
+        /// To implement an <see cref="IObjectSerializer"/> based on System.Text.Json, Newtonsoft.Json, or DataContractJsonSerializer see https://aka.ms/wct/storagehelper-migration
         /// </summary>
         /// <param name="objectSerializer">The serializer to use.</param>
         public RoamingObjectStorageHelper(IObjectSerializer objectSerializer)

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

@@ -0,0 +1,48 @@
+// 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.Reflection;
+using Microsoft.Toolkit.Diagnostics;
+using Windows.Storage;
+
+namespace Microsoft.Toolkit.Uwp.Helpers
+{
+    /// <summary>
+    /// 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>
+    public class SystemSerializer : IObjectSerializer
+    {
+        /// <summary>
+        /// Take a primitive value from storage and return it as the requested type using the <see cref="Convert.ChangeType(object, Type)"/> API.
+        /// </summary>
+        /// <typeparam name="T">Type to convert value to.</typeparam>
+        /// <param name="value">Value from storage to convert.</param>
+        /// <returns>Deserialized value or default value.</returns>
+        public T Deserialize<T>(object value)
+        {
+            var type = typeof(T);
+            var typeInfo = type.GetTypeInfo();
+
+            if (typeInfo.IsPrimitive || type == typeof(string))
+            {
+                return (T)Convert.ChangeType(value, type);
+            }
+
+            return ThrowHelper.ThrowNotSupportedException<T>("This serializer can only handle primitive types and strings. Please implement your own IObjectSerializer for more complex scenarios.");
+        }
+
+        /// <summary>
+        /// Returns the value so that it can be serialized by the <see cref="ApplicationDataContainer"/> API directly.
+        /// </summary>
+        /// <typeparam name="T">Type to serialize from.</typeparam>
+        /// <param name="value">Value to serialize.</param>
+        /// <returns>String representation of value.</returns>
+        public object Serialize<T>(T value)
+        {
+            return value;
+        }
+    }
+}