From 6b901d8309b44ab809c3dd07a5ed5676c47d3cef Mon Sep 17 00:00:00 2001
From: Rosario Pulella <RosarioPulella@gmail.com>
Date: Tue, 26 Jan 2021 16:53:00 -0500
Subject: [PATCH 1/5] Remove JsonObjectSerilizer and have storage helpers
 requiere a serilizer

---
 .../ObjectStorage/BaseObjectStorageHelper.cs  |  7 ++---
 .../ObjectStorage/JsonObjectSerializer.cs     | 29 -------------------
 .../ObjectStorage/LocalObjectStorageHelper.cs |  5 ++--
 .../RoamingObjectStorageHelper.cs             |  5 ++--
 4 files changed, 7 insertions(+), 39 deletions(-)
 delete mode 100644 Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/JsonObjectSerializer.cs

diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/BaseObjectStorageHelper.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/BaseObjectStorageHelper.cs
index bf724ac796e..d273c8b3d39 100644
--- a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/BaseObjectStorageHelper.cs
+++ b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/BaseObjectStorageHelper.cs
@@ -21,14 +21,13 @@ public abstract class BaseObjectStorageHelper : IObjectStorageHelper
         /// <summary>
         /// Initializes a new instance of the <see cref="BaseObjectStorageHelper"/> class,
         /// which can read and write data using the provided <see cref="IObjectSerializer"/>;
-        /// if none is provided, a default Json serializer will be used (based on <see cref="DataContractSerializer"/>).
-        /// In 6.1 and older the default Serializer was based on Newtonsoft.Json and the new default Serializer may behave differently.
+        /// 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
         /// </summary>
         /// <param name="objectSerializer">The serializer to use.</param>
-        public BaseObjectStorageHelper(IObjectSerializer objectSerializer = null)
+        public BaseObjectStorageHelper(IObjectSerializer objectSerializer)
         {
-            serializer = objectSerializer ?? new JsonObjectSerializer();
+            serializer = objectSerializer ?? throw new ArgumentNullException(nameof(objectSerializer));
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/JsonObjectSerializer.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/JsonObjectSerializer.cs
deleted file mode 100644
index cb962714b2d..00000000000
--- a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/JsonObjectSerializer.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// 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.IO;
-using System.Runtime.Serialization.Json;
-using System.Text;
-
-namespace Microsoft.Toolkit.Uwp.Helpers
-{
-    internal class JsonObjectSerializer : IObjectSerializer
-    {
-        public string Serialize<T>(T value)
-        {
-            using var sr = new MemoryStream();
-
-            new DataContractJsonSerializer(typeof(T)).WriteObject(sr, value);
-            var json = sr.ToArray();
-            return Encoding.UTF8.GetString(json, 0, json.Length);
-        }
-
-        public T Deserialize<T>(string value)
-        {
-            using var ms = new MemoryStream(Encoding.UTF8.GetBytes(value));
-
-            return (T)new DataContractJsonSerializer(typeof(T)).ReadObject(ms);
-        }
-    }
-}
diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs
index 0b717fb2d83..f56aada41da 100644
--- a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs
+++ b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs
@@ -15,12 +15,11 @@ public class LocalObjectStorageHelper : BaseObjectStorageHelper
         /// <summary>
         /// Initializes a new instance of the <see cref="LocalObjectStorageHelper"/> class,
         /// which can read and write data using the provided <see cref="IObjectSerializer"/>;
-        /// if none is provided, a default Json serializer will be used (based on <see cref="DataContractSerializer"/>).
-        /// In 6.1 and older the default Serializer was based on Newtonsoft.Json and the new default Serializer may behave differently.
+        /// 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
         /// </summary>
         /// <param name="objectSerializer">The serializer to use.</param>
-        public LocalObjectStorageHelper(IObjectSerializer objectSerializer = null)
+        public LocalObjectStorageHelper(IObjectSerializer objectSerializer)
             : base(objectSerializer)
         {
             Settings = ApplicationData.Current.LocalSettings;
diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/RoamingObjectStorageHelper.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/RoamingObjectStorageHelper.cs
index e2d9ae9b2b6..d4580e4f34a 100644
--- a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/RoamingObjectStorageHelper.cs
+++ b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/RoamingObjectStorageHelper.cs
@@ -15,12 +15,11 @@ 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"/>;
-        /// if none is provided, a default Json serializer will be used (based on <see cref="DataContractSerializer"/>).
-        /// In 6.1 and older the default Serializer was based on Newtonsoft.Json and the new default Serializer may behave differently.
+        /// 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
         /// </summary>
         /// <param name="objectSerializer">The serializer to use.</param>
-        public RoamingObjectStorageHelper(IObjectSerializer objectSerializer = null)
+        public RoamingObjectStorageHelper(IObjectSerializer objectSerializer)
             : base(objectSerializer)
         {
             Settings = ApplicationData.Current.RoamingSettings;

From b664b23a83a36f2f80e3174417d495edb53d889b Mon Sep 17 00:00:00 2001
From: michael-hawker <24302614+michael-hawker@users.noreply.github.com>
Date: Wed, 27 Jan 2021 16:24:04 -0800
Subject: [PATCH 2/5] 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.
---
 .../Controls/SampleAppMarkdownRenderer.cs     |  2 +-
 .../Models/Sample.cs                          |  2 +-
 .../Models/Samples.cs                         |  6 +--
 .../Object Storage/ObjectStoragePage.xaml     | 43 ++++++++++-------
 .../Object Storage/ObjectStoragePage.xaml.cs  | 32 +++----------
 .../ObjectStorage/BaseObjectStorageHelper.cs  | 21 ++------
 .../ObjectStorage/IObjectSerializer.cs        |  8 ++--
 .../ObjectStorage/LocalObjectStorageHelper.cs |  2 +-
 .../RoamingObjectStorageHelper.cs             |  4 +-
 .../Helpers/ObjectStorage/SystemSerializer.cs | 48 +++++++++++++++++++
 .../Helpers/SystemInformation.cs              |  2 +-
 11 files changed, 96 insertions(+), 74 deletions(-)
 create mode 100644 Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/SystemSerializer.cs

diff --git a/Microsoft.Toolkit.Uwp.SampleApp/Controls/SampleAppMarkdownRenderer.cs b/Microsoft.Toolkit.Uwp.SampleApp/Controls/SampleAppMarkdownRenderer.cs
index dc671f7c5a6..ecc9cb6cc2a 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/Controls/SampleAppMarkdownRenderer.cs
+++ b/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.
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/Models/Sample.cs b/Microsoft.Toolkit.Uwp.SampleApp/Models/Sample.cs
index 1db3fbd9e7e..157caa2114b 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/Models/Sample.cs
+++ b/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);
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/Models/Samples.cs b/Microsoft.Toolkit.Uwp.SampleApp/Models/Samples.cs
index 901bea050e8..0aa18896ad4 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/Models/Samples.cs
+++ b/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);
         }
     }
 }
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Object Storage/ObjectStoragePage.xaml b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Object Storage/ObjectStoragePage.xaml
index e782345850d..3fc3f747d91 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Object Storage/ObjectStoragePage.xaml	
+++ b/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>
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Object Storage/ObjectStoragePage.xaml.cs b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Object Storage/ObjectStoragePage.xaml.cs
index 7bde074a771..8f18c5865ee 100644
--- a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Object Storage/ObjectStoragePage.xaml.cs	
+++ b/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);
         }
     }
 }
diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/BaseObjectStorageHelper.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/BaseObjectStorageHelper.cs
index d273c8b3d39..df446a3b85d 100644
--- a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/BaseObjectStorageHelper.cs
+++ b/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);
         }
     }
 }
diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/IObjectSerializer.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/IObjectSerializer.cs
index 3dbad93431e..44bc8b1adac 100644
--- a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/IObjectSerializer.cs
+++ b/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);
     }
 }
diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs
index f56aada41da..ff56f155ec4 100644
--- a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs
+++ b/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)
diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/RoamingObjectStorageHelper.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/RoamingObjectStorageHelper.cs
index d4580e4f34a..bfd8e7884ed 100644
--- a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/RoamingObjectStorageHelper.cs
+++ b/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)
diff --git a/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/SystemSerializer.cs b/Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/SystemSerializer.cs
new file mode 100644
index 00000000000..61f247d3eed
--- /dev/null
+++ b/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;
+        }
+    }
+}
diff --git a/Microsoft.Toolkit.Uwp/Helpers/SystemInformation.cs b/Microsoft.Toolkit.Uwp/Helpers/SystemInformation.cs
index 72357b3f790..42c06cdb545 100644
--- a/Microsoft.Toolkit.Uwp/Helpers/SystemInformation.cs
+++ b/Microsoft.Toolkit.Uwp/Helpers/SystemInformation.cs
@@ -21,7 +21,7 @@ namespace Microsoft.Toolkit.Uwp.Helpers
     /// </summary>
     public sealed class SystemInformation
     {
-        private readonly LocalObjectStorageHelper _localObjectStorageHelper = new LocalObjectStorageHelper();
+        private readonly LocalObjectStorageHelper _localObjectStorageHelper = new LocalObjectStorageHelper(new SystemSerializer());
         private DateTime _sessionStart;
 
         /// <summary>

From 2086d1bccb6c9901a52d3da19e0c736268f19385 Mon Sep 17 00:00:00 2001
From: michael-hawker <24302614+michael-hawker@users.noreply.github.com>
Date: Wed, 27 Jan 2021 17:02:15 -0800
Subject: [PATCH 3/5] Add initial compatibility and serializer tests for the
 updates to BaseObjectStorage

---
 GazeInputTest/GazeInputTest.csproj            |  2 +-
 .../Helpers/JsonObjectSerializer.cs           | 47 ++++++++++
 .../Helpers/SystemTextJsonSerializer.cs       | 20 +++++
 .../Helpers/Test_StorageHelper.cs             | 85 ++++++++++++-------
 UnitTests/UnitTests.UWP/UnitTests.UWP.csproj  |  9 ++
 5 files changed, 130 insertions(+), 33 deletions(-)
 create mode 100644 UnitTests/UnitTests.UWP/Helpers/JsonObjectSerializer.cs
 create mode 100644 UnitTests/UnitTests.UWP/Helpers/SystemTextJsonSerializer.cs

diff --git a/GazeInputTest/GazeInputTest.csproj b/GazeInputTest/GazeInputTest.csproj
index 9364b18cddc..3454b492f5c 100644
--- a/GazeInputTest/GazeInputTest.csproj
+++ b/GazeInputTest/GazeInputTest.csproj
@@ -12,7 +12,7 @@
     <DefaultLanguage>en-US</DefaultLanguage>
     <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
     <TargetPlatformVersion Condition=" '$(TargetPlatformVersion)' == '' ">10.0.19041.0</TargetPlatformVersion>
-    <TargetPlatformMinVersion>10.0.17134.0</TargetPlatformMinVersion>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
     <MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
diff --git a/UnitTests/UnitTests.UWP/Helpers/JsonObjectSerializer.cs b/UnitTests/UnitTests.UWP/Helpers/JsonObjectSerializer.cs
new file mode 100644
index 00000000000..7df00beec25
--- /dev/null
+++ b/UnitTests/UnitTests.UWP/Helpers/JsonObjectSerializer.cs
@@ -0,0 +1,47 @@
+// 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.Uwp.Helpers;
+using Newtonsoft.Json;
+
+namespace UnitTests.UWP.Helpers
+{
+    /// <summary>
+    /// This is a Serializer which should mimic the previous functionality of 6.1.1 release of the Toolkit with Newtonsoft.Json.
+    /// </summary>
+    internal class JsonObjectSerializer : IObjectSerializer
+    {
+        public T Deserialize<T>(object value)
+        {
+            var type = typeof(T);
+            var typeInfo = type.GetTypeInfo();
+
+            // Note: If you're creating a new app, you could just use the serializer directly.
+            // This if/return combo is to maintain compatibility with 6.1.1
+            if (typeInfo.IsPrimitive || type == typeof(string))
+            {
+                return (T)Convert.ChangeType(value, type);
+            }
+
+            return JsonConvert.DeserializeObject<T>((string)value);
+        }
+
+        public object Serialize<T>(T value)
+        {
+            var type = typeof(T);
+            var typeInfo = type.GetTypeInfo();
+
+            // Note: If you're creating a new app, you could just use the serializer directly.
+            // This if/return combo is to maintain compatibility with 6.1.1
+            if (typeInfo.IsPrimitive || type == typeof(string))
+            {
+                return value;
+            }
+
+            return JsonConvert.SerializeObject(value);
+        }
+    }
+}
diff --git a/UnitTests/UnitTests.UWP/Helpers/SystemTextJsonSerializer.cs b/UnitTests/UnitTests.UWP/Helpers/SystemTextJsonSerializer.cs
new file mode 100644
index 00000000000..4b6a2c576c9
--- /dev/null
+++ b/UnitTests/UnitTests.UWP/Helpers/SystemTextJsonSerializer.cs
@@ -0,0 +1,20 @@
+// 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.Text.Json;
+using Microsoft.Toolkit.Uwp.Helpers;
+
+namespace UnitTests.UWP.Helpers
+{
+    /// <summary>
+    /// Example class of writing a new <see cref="IObjectSerializer"/> that uses System.Text.Json.
+    /// </summary>
+    internal class SystemTextJsonSerializer : IObjectSerializer
+    {
+        public T Deserialize<T>(object value) => JsonSerializer.Deserialize<T>(value as string);
+
+        public object Serialize<T>(T value) => JsonSerializer.Serialize(value);
+    }
+}
diff --git a/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs b/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
index 53698707f70..106da878dd6 100644
--- a/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
+++ b/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
@@ -5,15 +5,32 @@
 using Microsoft.Toolkit.Uwp.Helpers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
-using System.Text.Json;
-using UnitTests.UI;
+using Newtonsoft.Json;
+using UnitTests.UWP.Helpers;
+using System.Diagnostics.Contracts;
 
 namespace UnitTests.Helpers
 {
     [TestClass]
     public class Test_StorageHelper
     {
-        private LocalObjectStorageHelper storageHelper = new LocalObjectStorageHelper();
+        private LocalObjectStorageHelper _localStorageHelperSystem = new LocalObjectStorageHelper(new SystemSerializer());
+        private LocalObjectStorageHelper _localStorageHelperJsonCompat = new LocalObjectStorageHelper(new JsonObjectSerializer());
+
+        private LocalObjectStorageHelper _localStorageHelperJsonNew = new LocalObjectStorageHelper(new SystemTextJsonSerializer());
+
+        /// <summary>
+        /// Checks that we're running 10.0.3 version of Newtonsoft.Json package which we used in 6.1.1.
+        /// </summary>
+        [TestCategory("Helpers")]
+        [TestMethod]
+        public void Test_StorageHelper_CheckNewtonsoftVersion()
+        {
+            var version = typeof(JsonSerializer).Assembly.GetName().Version;
+            Assert.AreEqual(10, version.Major);
+            Assert.AreEqual(0, version.Minor);
+            Assert.AreEqual(0, version.Revision); // Apparently the file revision was not updated for the updated package
+        }
 
         [TestCategory("Helpers")]
         [TestMethod]
@@ -23,38 +40,45 @@ public void Test_StorageHelper_LegacyIntTest()
 
             int input = 42;
 
-            // simulate previous version by generating json and manually inserting it as string
-            string jsonInput = JsonSerializer.Serialize(input);
-
-            storageHelper.Save<string>(key, jsonInput);
+            // Use our previous Json layer to store value
+            _localStorageHelperJsonCompat.Save(key, input);
 
-            // now read it as int to valid that the change works
-            int output = storageHelper.Read<int>(key, 0);
+            // But try and read from our new system to see if it works
+            int output = _localStorageHelperSystem.Read(key, 0);
 
             Assert.AreEqual(input, output);
         }
 
-        [Ignore]
+        /// <summary>
+        /// If we try and deserialize a complex type with the <see cref="SystemSerializer"/>, we do a check ourselves and will throw our own exception.
+        /// </summary>
         [TestCategory("Helpers")]
         [TestMethod]
-        public void Test_StorageHelper_LegacyDateTest()
+        [ExpectedException(typeof(NotSupportedException))]
+        public void Test_StorageHelper_LegacyDateTestFailure()
         {
             string key = "ChristmasDay";
 
             DateTime input = new DateTime(2017, 12, 25);
 
-            // simulate previous version by generating json and manually inserting it as string
-            string jsonInput = JsonSerializer.Serialize(input);
-
-            storageHelper.Save<string>(key, jsonInput);
+            _localStorageHelperJsonCompat.Save(key, input);
 
             // now read it as int to valid that the change works
-            DateTime output = storageHelper.Read<DateTime>(key, DateTime.Today);
+            DateTime output = _localStorageHelperSystem.Read(key, DateTime.Today);
+        }
 
-            Assert.AreEqual(input, output);
+        /// <summary>
+        /// The <see cref="SystemSerializer"/> doesn't support complex types, since it just passes through directly.
+        /// We'll get the argument exception from the <see cref="ApplicationDataContainer"/> API.
+        /// </summary>
+        [TestCategory("Helpers")]
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentException))]
+        public void Test_StorageHelper_DateTestFailure()
+        {
+            _localStorageHelperSystem.Save("Today", DateTime.Today);
         }
 
-        [Ignore]
         [TestCategory("Helpers")]
         [TestMethod]
         public void Test_StorageHelper_LegacyInternalClassTest()
@@ -64,12 +88,10 @@ public void Test_StorageHelper_LegacyInternalClassTest()
             UI.Person input = new UI.Person() { Name = "Joe Bloggs", Age = 42 };
 
             // simulate previous version by generating json and manually inserting it as string
-            string jsonInput = JsonSerializer.Serialize(input);
-
-            storageHelper.Save<string>(key, jsonInput);
+            _localStorageHelperJsonCompat.Save(key, input);
 
             // now read it as int to valid that the change works
-            UI.Person output = storageHelper.Read<UI.Person>(key, null);
+            UI.Person output = _localStorageHelperJsonCompat.Read<UI.Person>(key, null);
 
             Assert.IsNotNull(output);
             Assert.AreEqual(input.Name, output.Name);
@@ -82,15 +104,14 @@ public void Test_StorageHelper_LegacyPublicClassTest()
         {
             string key = "Contact";
 
+            // Here's we're serializing a different class which has the same properties as our other class below.
             UI.Person input = new UI.Person() { Name = "Joe Bloggs", Age = 42 };
 
             // simulate previous version by generating json and manually inserting it as string
-            string jsonInput = JsonSerializer.Serialize(input);
-
-            storageHelper.Save(key, jsonInput);
+            _localStorageHelperJsonCompat.Save(key, input);
 
             // now read it as int to valid that the change works
-            Person output = storageHelper.Read<Person>(key, null);
+            Person output = _localStorageHelperJsonCompat.Read<Person>(key, null);
 
             Assert.IsNotNull(output);
             Assert.AreEqual(input.Name, output.Name);
@@ -105,10 +126,10 @@ public void Test_StorageHelper_IntTest()
 
             int input = 42;
 
-            storageHelper.Save<int>(key, input);
+            _localStorageHelperSystem.Save<int>(key, input);
 
             // now read it as int to valid that the change works
-            int output = storageHelper.Read<int>(key, 0);
+            int output = _localStorageHelperSystem.Read<int>(key, 0);
 
             Assert.AreEqual(input, output);
         }
@@ -121,10 +142,10 @@ public void Test_StorageHelper_NewDateTest()
 
             DateTime input = new DateTime(2017, 12, 25);
 
-            storageHelper.Save<DateTime>(key, input);
+            _localStorageHelperJsonNew.Save(key, input);
 
             // now read it as int to valid that the change works
-            DateTime output = storageHelper.Read<DateTime>(key, DateTime.Today);
+            DateTime output = _localStorageHelperJsonNew.Read(key, DateTime.Today);
 
             Assert.AreEqual(input, output);
         }
@@ -137,10 +158,10 @@ public void Test_StorageHelper_NewPersonTest()
 
             Person input = new Person() { Name = "Joe Bloggs", Age = 42 };
 
-            storageHelper.Save<Person>(key, input);
+            _localStorageHelperJsonNew.Save(key, input);
 
             // now read it as int to valid that the change works
-            Person output = storageHelper.Read<Person>(key, null);
+            Person output = _localStorageHelperJsonNew.Read<Person>(key, null);
 
             Assert.IsNotNull(output);
             Assert.AreEqual(input.Name, output.Name);
diff --git a/UnitTests/UnitTests.UWP/UnitTests.UWP.csproj b/UnitTests/UnitTests.UWP/UnitTests.UWP.csproj
index b9430d3a797..c2bc7e1cc2a 100644
--- a/UnitTests/UnitTests.UWP/UnitTests.UWP.csproj
+++ b/UnitTests/UnitTests.UWP/UnitTests.UWP.csproj
@@ -119,6 +119,13 @@
     <PackageReference Include="MSTest.TestFramework">
       <Version>2.1.0</Version>
     </PackageReference>
+    <PackageReference Include="Newtonsoft.Json">
+      <Version>10.0.3</Version>
+      <!-- DO NOT UPGRADE THIS PACKAGE FROM 10.0.3, this is used for upgrade testing between 6.1.1 and 7.0.0 for the Object Serializers -->
+    </PackageReference>
+    <PackageReference Include="System.Text.Json">
+      <Version>4.7.2</Version>
+    </PackageReference>
     <PackageReference Include="System.Xml.XPath.XmlDocument">
       <Version>4.3.0</Version>
     </PackageReference>
@@ -141,6 +148,8 @@
     <Compile Include="Extensions\Test_EnumValuesExtension.cs" />
     <Compile Include="Extensions\Test_NullableBoolMarkupExtension.cs" />
     <Compile Include="GlobalSuppressions.cs" />
+    <Compile Include="Helpers\JsonObjectSerializer.cs" />
+    <Compile Include="Helpers\SystemTextJsonSerializer.cs" />
     <Compile Include="Helpers\TestCollectionCapableDeepLinkParser.cs" />
     <Compile Include="Helpers\TestDeepLinkParser.cs" />
     <Compile Include="Extensions\Test_DispatcherQueueExtensions.cs" />

From a34ce96b0f6a2a18cc6099e1526aaebcd38fcf1e Mon Sep 17 00:00:00 2001
From: michael-hawker <24302614+michael-hawker@users.noreply.github.com>
Date: Thu, 28 Jan 2021 01:47:03 -0800
Subject: [PATCH 4/5] Fix unresolved comment link.

---
 UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs b/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
index 106da878dd6..53ad97ea037 100644
--- a/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
+++ b/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
@@ -2,12 +2,12 @@
 // 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 Microsoft.Toolkit.Uwp.Helpers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
 using Newtonsoft.Json;
 using UnitTests.UWP.Helpers;
-using System.Diagnostics.Contracts;
+using Windows.Storage;
 
 namespace UnitTests.Helpers
 {

From 0741d596c88d19df50c8451bd538c3d993022168 Mon Sep 17 00:00:00 2001
From: michael-hawker <24302614+michael-hawker@users.noreply.github.com>
Date: Thu, 28 Jan 2021 10:11:46 -0800
Subject: [PATCH 5/5] Fix test that was working locally but failing in CI due
 to different OS? code paths throwing different Exception Types...

---
 .../UnitTests.UWP/Helpers/Test_StorageHelper.cs  | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs b/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
index 53ad97ea037..c5162f2f389 100644
--- a/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
+++ b/UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs
@@ -73,10 +73,22 @@ public void Test_StorageHelper_LegacyDateTestFailure()
         /// </summary>
         [TestCategory("Helpers")]
         [TestMethod]
-        [ExpectedException(typeof(ArgumentException))]
         public void Test_StorageHelper_DateTestFailure()
         {
-            _localStorageHelperSystem.Save("Today", DateTime.Today);
+            Exception expectedException = null;
+
+            // We can't use standard exception checking here like Assert.Throws or ExpectedException
+            // as local and online platforms seem to throw different exception types :(
+            try
+            {
+                _localStorageHelperSystem.Save("Today", DateTime.Today);
+            }
+            catch (Exception exception)
+            {
+                expectedException = exception;
+            }
+
+            Assert.IsNotNull(expectedException, "Was expecting an Exception.");
         }
 
         [TestCategory("Helpers")]