Faster instance creation for ValuesJsonConverter (#119)

* Update benchmark to use .NET Core 3.1

* Use cached constructor delegate

* Moved faster object activation to separate class

Author: Turnerj

Benchmarks/Schema.NET.Benchmarks/SchemaBenchmarkBase.cs

@@ -13,7 +13,7 @@ namespace Schema.NET.Benchmarks
     [CsvMeasurementsExporter]
     [RPlotExporter]
     [SimpleJob(RuntimeMoniker.Net472)]
-    [SimpleJob(RuntimeMoniker.NetCoreApp30)]
+    [SimpleJob(RuntimeMoniker.NetCoreApp31)]
     public abstract class SchemaBenchmarkBase
     {
         protected Thing Thing { get; set; }

Source/Schema.NET/FastActivator.cs

@@ -0,0 +1,61 @@
+namespace Schema.NET
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Linq.Expressions;
+    using System.Reflection;
+    using System.Text;
+
+    /// <summary>
+    /// A faster version of <see cref="Activator.CreateInstance(System.Type, object[])"/> by providing constructor delegates.
+    /// </summary>
+    internal static class FastActivator
+    {
+        private static readonly ConcurrentDictionary<(Type, Type), Delegate> ConstructorDelegateLookup = new ConcurrentDictionary<(Type, Type), Delegate>();
+
+        /// <summary>
+        /// Creates a constructor delegate for the specified type.
+        /// </summary>
+        /// <typeparam name="T1">Type of first argument for constructor.</typeparam>
+        /// <param name="objectType">The object to find the constructor.</param>
+        /// <returns>The constructor delegate.</returns>
+        public static Func<T1, object> GetDynamicConstructor<T1>(Type objectType)
+        {
+            var constructorKey = (objectType, typeof(T1));
+            if (!ConstructorDelegateLookup.TryGetValue(constructorKey, out var constructorDelegate))
+            {
+                var constructor = GetConstructorInfo(objectType, typeof(T1));
+                constructorDelegate = CreateConstructorDelegate<T1>(constructor);
+                ConstructorDelegateLookup.TryAdd(constructorKey, constructorDelegate);
+            }
+
+            return constructorDelegate as Func<T1, object>;
+        }
+
+        private static Func<T1, object> CreateConstructorDelegate<T1>(ConstructorInfo constructor) => Expression.Lambda<Func<T1, object>>(
+                Expression.Convert(
+                    Expression.New(constructor, ConstructorParameter<T1>.SingleParameter),
+                    typeof(object)),
+                ConstructorParameter<T1>.SingleParameter).Compile();
+
+        private static ConstructorInfo GetConstructorInfo(Type objectType, Type parameter1)
+        {
+            foreach (var constructor in objectType.GetTypeInfo().DeclaredConstructors)
+            {
+                var parameters = constructor.GetParameters();
+                if (constructor.IsPublic && parameters.Length == 1 && parameters[0].ParameterType == parameter1)
+                {
+                    return constructor;
+                }
+            }
+
+            return null;
+        }
+
+        private static class ConstructorParameter<T1>
+        {
+            public static readonly ParameterExpression[] SingleParameter = new[] { Expression.Parameter(typeof(T1)) };
+        }
+    }
+}

Source/Schema.NET/Schema.NET.csproj

@@ -46,6 +46,10 @@
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     <PackageReference Include="System.Memory" Version="4.5.3" />
   </ItemGroup>
+  
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard1.1' Or '$(TargetFramework)' == 'net461'">
+    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+  </ItemGroup>
 
   <ItemGroup Label="Analyzer Package References">
     <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" PrivateAssets="all" Version="2.9.8" />

Source/Schema.NET/ValuesJsonConverter.cs

@@ -1,11 +1,11 @@
 namespace Schema.NET
 {
     using System;
-    using System.Collections;
+    using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.Globalization;
-    using System.Linq;
+    using System.Linq.Expressions;
     using System.Reflection;
     using System.Xml;
     using Newtonsoft.Json;
@@ -71,6 +71,8 @@ public override object ReadJson(
                 throw new ArgumentNullException(nameof(serializer));
             }
 
+            var dynamicConstructor = FastActivator.GetDynamicConstructor<IEnumerable<object>>(objectType);
+
             if (reader.TokenType == JsonToken.StartArray)
             {
                 var items = new List<object>();
@@ -91,12 +93,12 @@ public override object ReadJson(
                     items.Add(item);
                 }
 
-                return Activator.CreateInstance(objectType, items);
+                return dynamicConstructor(items);
             }
             else if (reader.TokenType != JsonToken.Null)
             {
                 var item = ProcessToken(reader, objectType.GenericTypeArguments, serializer);
-                return Activator.CreateInstance(objectType, (IEnumerable)new[] { item });
+                return dynamicConstructor(new[] { item });
             }
 
             return default;