Rework JsonConvert for performance and maintainability

nanoFramework.Json.Benchmark/Base/BaseIterationBenchmark.cs

@@ -13,7 +13,7 @@ public abstract class BaseIterationBenchmark
 
         public void RunInIteration(Action methodToRun)
         {
-            for (int i = 0; i < IterationCount; i++)
+            for (var i = 0; i < IterationCount; i++)
             {
                 methodToRun();
             }

nanoFramework.Json.Benchmark/Program.cs

@@ -3,8 +3,8 @@
 // See LICENSE file in the project root for full license information.
 //
 
+using System;
 using nanoFramework.Benchmark;
-using System.Diagnostics;
 using System.Threading;
 
 namespace nanoFramework.Json.Benchmark
@@ -13,7 +13,7 @@ public static class Program
     {
         public static void Main()
         {
-            Debug.WriteLine("Hello from nanoFramework JSON benchmark!");
+            Console.WriteLine("Hello from nanoFramework JSON benchmark!");
             BenchmarkRunner.Run(typeof(IAssemblyHandler).Assembly);
             Thread.Sleep(Timeout.Infinite);
         }

nanoFramework.Json.Benchmark/TypeBenchmarks.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections;
+using System.Text;
+using nanoFramework.Benchmark;
+using nanoFramework.Benchmark.Attributes;
+using nanoFramework.Json.Benchmark.Base;
+
+namespace nanoFramework.Json.Benchmark
+{
+    [IterationCount(100)]
+    public class TypeBenchmarks: BaseIterationBenchmark
+    {
+        protected override int IterationCount => 200;
+
+        private readonly ArrayList _list = new();
+        private const string ArrayListFullName = "System.Collections.ArrayList";
+        private static readonly Type ArrayListType = typeof(ArrayList);
+
+        [Benchmark]
+        public void Benchmark_FullName_Comparison()
+        {
+            RunInIteration(() =>
+            {
+                if (!ArrayListFullName.Equals(_list.GetType().FullName))
+                {
+                    throw new Exception();
+                }
+            });
+        }
+
+        [Benchmark]
+        public void Benchmark_Type_Comparison()
+        {
+            RunInIteration(() =>
+            {
+                if (_list.GetType() != typeof(ArrayList))
+                {
+                    throw new Exception();
+                }
+            });
+        }
+
+        [Benchmark]
+        public void Benchmark_Type_Comparison_Static()
+        {
+            RunInIteration(() =>
+            {
+                if (_list.GetType() != ArrayListType)
+                {
+                    throw new Exception();
+                }
+            });
+        }
+    }
+}

nanoFramework.Json.Benchmark/nanoFramework.Json.Benchmark.nfproj

@@ -29,6 +29,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="DeserializationBenchmarks\ReferenceTypesDeserializationBenchmark.cs" />
     <Compile Include="SerializationBenchmarks\ValueTypesSerializationBenchmark.cs" />
+    <Compile Include="TypeBenchmarks.cs" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="mscorlib, Version=1.15.6.0, Culture=neutral, PublicKeyToken=c07d481e9758c731">

nanoFramework.Json.Test/Configuration/SettingsTests.cs

@@ -4,23 +4,67 @@
 //
 
 using nanoFramework.Json.Configuration;
+using nanoFramework.Json.Resolvers;
+using nanoFramework.Json.Test.Mocks;
 using nanoFramework.TestFramework;
 
 namespace nanoFramework.Json.Test.Configuration
 {
     [TestClass]
     public class SettingsTests
     {
+        private static bool _caseSensitive;
+        private static IMemberResolver _resolver;
+        private static bool _throwExceptionWhenPropertyNotFound;
+
+        [Cleanup]
+        public void Cleanup()
+        {
+            // Restore default settings
+            JsonSerializerOptions.Default.PropertyNameCaseInsensitive = _caseSensitive;
+            JsonSerializerOptions.Default.Resolver = _resolver;
+            JsonSerializerOptions.Default.ThrowExceptionWhenPropertyNotFound = _throwExceptionWhenPropertyNotFound;
+        }
+
+        [Setup]
+        public void Setup()
+        {
+            // Capture default settings
+            _caseSensitive = JsonSerializerOptions.Default.PropertyNameCaseInsensitive;
+            _resolver = JsonSerializerOptions.Default.Resolver;
+            _throwExceptionWhenPropertyNotFound = JsonSerializerOptions.Default.ThrowExceptionWhenPropertyNotFound;
+        }
+
+        [TestMethod]
+        public void CaseSensitive_Should_Delegate_To_JsonSettings()
+        {
+#pragma warning disable CS0618
+            Settings.CaseSensitive = !Settings.CaseSensitive;
+
+            Assert.AreEqual(Settings.CaseSensitive, !JsonSerializerOptions.Default.PropertyNameCaseInsensitive);
+#pragma warning restore CS0618
+        }
+
         [TestMethod]
-        public void CaseSensitive_Should_BeTrueByDefault()
+        public void Resolver_Should_Delegate_To_JsonSettings()
         {
-            Assert.AreEqual(Settings.CaseSensitive, true);
+            var resolver = new MockMemberResolver();
+
+#pragma warning disable CS0618
+            Settings.Resolver = resolver;
+
+            Assert.AreEqual(resolver, JsonSerializerOptions.Default.Resolver);
+#pragma warning restore CS0618
         }
 
         [TestMethod]
-        public void ThrowExceptionWhenPropertyNotFound_Should_BeFalseByDefault()
+        public void ThrowExceptionWhenPropertyNotFound_Should_Delegate_To_JsonSettings()
         {
-            Assert.AreEqual(Settings.ThrowExceptionWhenPropertyNotFound, false);
+#pragma warning disable CS0618
+            Settings.ThrowExceptionWhenPropertyNotFound = !Settings.ThrowExceptionWhenPropertyNotFound;
+
+            Assert.AreEqual(Settings.ThrowExceptionWhenPropertyNotFound, JsonSerializerOptions.Default.ThrowExceptionWhenPropertyNotFound);
+#pragma warning restore CS0618
         }
     }
 }

nanoFramework.Json.Test/JsonSettingsTests.cs

@@ -0,0 +1,25 @@
+//
+// Copyright (c) .NET Foundation and Contributors
+// See LICENSE file in the project root for full license information.
+//
+
+using nanoFramework.TestFramework;
+
+namespace nanoFramework.Json.Test
+{
+    [TestClass]
+    public class JsonSettingsTests
+    {
+        [TestMethod]
+        public void PropertyNameCaseInsensitive_Should_Be_False_By_Default()
+        {
+            Assert.IsFalse(JsonSerializerOptions.Default.PropertyNameCaseInsensitive);
+        }
+
+        [TestMethod]
+        public void ThrowExceptionWhenPropertyNotFound_Should_Be_False_By_Default()
+        {
+            Assert.IsFalse(JsonSerializerOptions.Default.PropertyNameCaseInsensitive);
+        }
+    }
+}

nanoFramework.Json.Test/JsonUnitTests.cs

@@ -930,7 +930,7 @@ public void CanDeserializeInvocationReceiveMessage_03()
             Assert.AreEqual(dserResult.target, "ReceiveAdvancedMessage", "target value is not correct");
 
             Assert.AreEqual((int)dserResult.arguments[2], 3, "arguments[2] value is not correct");
-            Assert.IsType(typeof(ArrayList), dserResult.arguments, "arguments type it's wrong after deserialization");
+            Assert.IsInstanceOfType(dserResult.arguments, typeof(ArrayList), "arguments type it's wrong after deserialization");
             Assert.AreEqual(dserResult.arguments.Count, 3, $"number of arguments is different than expected: {dserResult.arguments.Count}");
 
             Hashtable arg0 = (Hashtable)dserResult.arguments[0];
@@ -971,7 +971,7 @@ public void CanDeserializeInvocationReceiveMessage_04()
             Assert.AreEqual(dserResult.target, "ReceiveAdvancedMessage", "target value is not correct");
 
             Assert.AreEqual((int)dserResult.arguments[2], 3, "arguments[2] value is not correct");
-            Assert.IsType(typeof(ArrayList), dserResult.arguments, "arguments type it's wrong after deserialization");
+            Assert.IsInstanceOfType(dserResult.arguments, typeof(ArrayList), "arguments type it's wrong after deserialization");
             Assert.AreEqual(dserResult.arguments.Count, 3, $"number of arguments is different than expected: {dserResult.arguments.Count}");
 
             OutputHelper.WriteLine("Serializing dserResult.arguments[0]");
@@ -1022,7 +1022,7 @@ public void CanDeserializeInvocationReceiveMessage_05()
             Assert.AreEqual(dserResult.type, 1, "type value is not correct");
             Assert.AreEqual(dserResult.target, "ReceiveMessage", "target value is not correct");
 
-            Assert.IsType(typeof(ArrayList), dserResult.arguments, "arguments type it's wrong after deserialization");
+            Assert.IsInstanceOfType(dserResult.arguments, typeof(ArrayList), "arguments type it's wrong after deserialization");
             Assert.AreEqual(dserResult.arguments.Count, 2, $"number of arguments is different than expected: {dserResult.arguments.Count}");
 
             OutputHelper.WriteLine($"SerializingdserResult.arguments[0]:{dserResult.arguments[0]}");
@@ -1081,13 +1081,13 @@ public void DeserializeArrayList()
 
             Hashtable desired = (Hashtable)hash["desired"];
 
-            Assert.IsType(typeof(string), desired["Authorization"], "Authorization is not a string and it should be.");
+            Assert.IsInstanceOfType(desired["Authorization"], typeof(string), "Authorization is not a string and it should be.");
 
             Assert.AreEqual("sp=r&st=2021-06-12T09:11:53Z&se=2021-06-14T17:11:53Z&spr=https&sv=2020-02-10&sr=c&sig=rn125LiO55RSCoEs4IEaCgg%2BuXKETdEZQPygxVjCHiY%3D", (string)desired["Authorization"], "Authorization string doesn't match original value.");
 
             ArrayList files = (ArrayList)desired["Files"];
 
-            Assert.IsType(typeof(string), files[0]);
+            Assert.IsInstanceOfType(files[0], typeof(string));
             Assert.AreEqual("Iot.Device.Bmxx80.pe", (string)files[0]);
         }
 
@@ -1100,12 +1100,12 @@ public void DeserializeArrayListElements()
 
             Hashtable hash = (Hashtable)JsonConvert.DeserializeObject(correctValue, typeof(Hashtable));
 
-            Assert.IsType(typeof(string), hash["Authorization"], "Authorization is not a string and it should be.");
+            Assert.IsInstanceOfType(hash["Authorization"], typeof(string), "Authorization is not a string and it should be.");
             Assert.AreEqual("sp=r&st=2021-06-12T09:11:53Z&se=2021-06-14T17:11:53Z&spr=https&sv=2020-02-10&sr=c&sig=rn125LiO55RSCoEs4IEaCgg%2BuXKETdEZQPygxVjCHiY%3D", (string)hash["Authorization"], "Authorization string doesn't match original value.");
 
             ArrayList files = (ArrayList)hash["Files"];
 
-            Assert.IsType(typeof(string), files[0]);
+            Assert.IsInstanceOfType(files[0], typeof(string));
             Assert.AreEqual("Iot.Device.Bmxx80.pe", (string)files[0]);
         }
 

nanoFramework.Json.Test/Mocks/MockMemberResolver.cs

@@ -0,0 +1,13 @@
+using System;
+using nanoFramework.Json.Resolvers;
+
+namespace nanoFramework.Json.Test.Mocks
+{
+    internal class MockMemberResolver: IMemberResolver
+    {
+        public MemberSet Get(string memberName, Type objectType, JsonSerializerOptions options)
+        {
+            return new MemberSet(true);
+        }
+    }
+}

nanoFramework.Json.Test/Resolvers/MemberResolverCaseInsensitiveExceptionTests.cs

@@ -3,10 +3,8 @@
 // See LICENSE file in the project root for full license information.
 //
 
-using nanoFramework.Json.Configuration;
 using nanoFramework.Json.Resolvers;
 using nanoFramework.TestFramework;
-using System;
 
 namespace nanoFramework.Json.Test.Resolvers
 {
@@ -16,57 +14,33 @@ public class MemberResolverCaseInsensitiveExceptionTests
         private sealed class TestClass
         {
             public int NoGetProperty { private get; set; } = 1;
-            public int NoSetProperty { get; } = 1;
-        }
-
-        [Setup]
-        public void MemberResolverCaseInsensitiveExceptionTests_Setup()
-        {
-            Settings.ThrowExceptionWhenPropertyNotFound = true;
-            Settings.CaseSensitive = false;
-        }
-
-        [Cleanup]
-        public void MemberResolverCaseInsensitiveExceptionTests_Cleanup()
-        {
-            Settings.ThrowExceptionWhenPropertyNotFound = false;
-            Settings.CaseSensitive = true;
+            public int NoSetProperty => 1;
         }
 
         [TestMethod]
         public void MemberResolverCaseInsensitiveExceptionTests_Get_ShouldSkipPropertyWithoutGet()
         {
-            var resolver = new MemberResolver();
-
-            try
-            {
-                resolver.Get(nameof(TestClass.NoGetProperty), typeof(TestClass));
-            }
-            catch (DeserializationException)
+            var options = new JsonSerializerOptions
             {
-                // Intended. Method should throw this type of exception when no set method.
-                return;
-            }
+                PropertyNameCaseInsensitive = true,
+                ThrowExceptionWhenPropertyNotFound = true,
+            };
 
-            throw new InvalidOperationException($"Should throw {nameof(DeserializationException)}.");
+            var sut = new MemberResolver();
+            Assert.ThrowsException(typeof(DeserializationException), () => sut.Get(nameof(TestClass.NoGetProperty), typeof(TestClass), options));
         }
 
         [TestMethod]
         public void MemberResolverCaseInsensitiveExceptionTests_Get_ShouldSkipPropertyWithoutSet()
         {
-            var resolver = new MemberResolver();
-
-            try
-            {
-                resolver.Get(nameof(TestClass.NoSetProperty), typeof(TestClass));
-            }
-            catch (DeserializationException)
+            var options = new JsonSerializerOptions
             {
-                // Intended. Method should throw this type of exception when no set method.
-                return;
-            }
+                PropertyNameCaseInsensitive = true,
+                ThrowExceptionWhenPropertyNotFound = true,
+            };
 
-            throw new InvalidOperationException($"Should throw {nameof(DeserializationException)}.");
+            var sut = new MemberResolver();
+            Assert.ThrowsException(typeof(DeserializationException), () => sut.Get(nameof(TestClass.NoSetProperty), typeof(TestClass), options));
         }
     }
 }