Merge pull request #518 from johelvisguzman/fast-actvator

Added a fast activator to the in-memory context for increasing performance

Author: johelvisguzman

src/DotNetToolkit.Repository.InMemory/Internal/CloneableHelper.cs

@@ -2,18 +2,29 @@
 {
     using Extensions.Internal;
     using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
     using System.Linq;
     using System.Reflection;
     using Utility;
 
     internal static class CloneableHelper
     {
+        private readonly static ConcurrentDictionary<Type, IEnumerable<PropertyInfo>> _cache = new ConcurrentDictionary<Type, IEnumerable<PropertyInfo>>();
+
         public static object DeepCopy(object entity)
         {
             Guard.NotNull(entity, nameof(entity));
 
-            var newItem = Activator.CreateInstance(entity.GetType());
-            var properties = entity.GetType().GetRuntimeProperties().Where(x => x.IsPrimitive());
+            var type = entity.GetType();
+            var newItem = FastActivator.CreateInstance(type);
+
+            if (!_cache.TryGetValue(type, out IEnumerable<PropertyInfo> properties))
+            {
+                properties = type.GetRuntimeProperties().Where(x => x.IsPrimitive());
+
+                _cache[type] = properties;
+            }
 
             foreach (var propInfo in properties)
             {

src/DotNetToolkit.Repository.InMemory/Internal/FastActivator.cs

@@ -0,0 +1,32 @@
+namespace DotNetToolkit.Repository.InMemory.Internal
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Linq.Expressions;
+    using System.Reflection;
+
+    internal static class FastActivator
+    {
+        private readonly static ConcurrentDictionary<Type, Func<object>> _cache = new ConcurrentDictionary<Type, Func<object>>();
+
+        public static T CreateInstance<T>() where T : class
+        {
+            return (T)CreateInstance(typeof(T));
+        }
+
+        public static object CreateInstance(Type type)
+        {
+            if (!type.GetTypeInfo().IsClass)
+                return Activator.CreateInstance(type);
+
+            if (!_cache.TryGetValue(type, out Func<object> f))
+            {
+                f = Expression.Lambda<Func<object>>(Expression.New(type)).Compile();
+
+                _cache[type] = f;
+            }
+
+            return f();
+        }
+    }
+}