(GH-656) Add a new FastActivator to use throughout the entire solution

Author: johelvisguzman

src/DotNetToolkit.Repository.EntityFramework/Internal/EfRepositoryContextFactory.cs

@@ -69,7 +69,7 @@ public IRepositoryContext Create()
             }
 
             var underlyingContext = args.Count > 0
-                ? (TDbContext)Activator.CreateInstance(typeof(TDbContext), args.ToArray())
+                ? (TDbContext)FastActivator.CreateInstance(typeof(TDbContext), args.ToArray())
                 : RepositoryDependencyResolver.Current.Resolve<TDbContext>();
 
             return new EfRepositoryContext(underlyingContext);

src/DotNetToolkit.Repository.EntityFrameworkCore/Internal/EfCoreRepositoryContextFactory.cs

@@ -45,7 +45,7 @@ public EfCoreRepositoryContextFactory(DbContextOptions contextOptions)
         public IRepositoryContext Create()
         {
             var underlyingContext = _contextOptions != null
-                ? (TDbContext)Activator.CreateInstance(typeof(TDbContext), _contextOptions)
+                ? (TDbContext)FastActivator.CreateInstance(typeof(TDbContext), _contextOptions)
                 : RepositoryDependencyResolver.Current.Resolve<TDbContext>();
 
             return new EfCoreRepositoryContext(underlyingContext);

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

@@ -31,7 +31,7 @@ public static Type GetGenericTypeOrDefault([NotNull] this Type type)
         /// <returns>The default value of the specified type.</returns>
         public static object GetDefault([NotNull] this Type type)
         {
-            return type == null ? null : (type.GetTypeInfo().IsValueType ? Activator.CreateInstance(type) : null);
+            return type == null ? null : (type.GetTypeInfo().IsValueType ? FastActivator.CreateInstance(type) : null);
         }
 
         /// <summary>
@@ -176,7 +176,7 @@ public static object InvokeConstructor([NotNull] this Type type, [CanBeNull] Dic
                 return null;
 
             if (keyValues == null || keyValues.Count == 0)
-                return Activator.CreateInstance(type);
+                return FastActivator.CreateInstance(type);
 
             var kvs = keyValues.ToDictionary(x => x.Key, x => x.Value);
             var ctors = type.GetConstructors();
@@ -245,7 +245,7 @@ select pi
             }
             else
             {
-                obj = Activator.CreateInstance(type);
+                obj = FastActivator.CreateInstance(type);
             }
 
             if (kvs.Any())

src/DotNetToolkit.Repository/Extensions/Internal/TypeExtensions.cs

@@ -108,7 +108,7 @@ public object Resolve([NotNull] Type type)
                 {
                     try
                     {
-                        result = Activator.CreateInstance(type);
+                        result = FastActivator.CreateInstance(type);
                     }
                     catch (Exception ex)
                     {

src/DotNetToolkit.Repository/RepositoryDependencyResolver.cs

@@ -100,7 +100,7 @@ public IRepository<TEntity, TKey1, TKey2, TKey3> Create<TEntity, TKey1, TKey2, T
         /// <returns>The new repository.</returns>
         public T CreateInstance<T>() where T : class
         {
-            return (T)Activator.CreateInstance(typeof(T), new object[] { _options });
+            return (T)FastActivator.CreateInstance(typeof(T), new object[] { _options });
         }
 
         #endregion

src/DotNetToolkit.Repository/RepositoryFactory.cs

@@ -85,7 +85,7 @@ public IService<TEntity, TKey1, TKey2, TKey3> Create<TEntity, TKey1, TKey2, TKey
         /// <returns>The new service.</returns>
         public T CreateInstance<T>() where T : class
         {
-            return (T)Activator.CreateInstance(typeof(T), new object[] { _uowFactory });
+            return (T)FastActivator.CreateInstance(typeof(T), new object[] { _uowFactory });
         }
 
         #endregion

src/DotNetToolkit.Repository/Services/ServiceFactory.cs

@@ -157,7 +157,7 @@ public T CreateInstance<T>() where T : class
         {
             ThrowIfDisposed();
 
-            return (T)Activator.CreateInstance(typeof(T), new object[] { _options });
+            return (T)FastActivator.CreateInstance(typeof(T), new object[] { _options });
         }
 
         /// <summary>

src/DotNetToolkit.Repository/Transactions/UnitOfWork.cs

@@ -63,7 +63,7 @@ public IUnitOfWork Create()
         /// <returns>The new repository.</returns>
         public T CreateInstance<T>() where T : class
         {
-            return (T)Activator.CreateInstance(typeof(T), new object[] { _options });
+            return (T)FastActivator.CreateInstance(typeof(T), new object[] { _options });
         }
 
         #endregion

src/DotNetToolkit.Repository/Transactions/UnitOfWorkFactory.cs

@@ -0,0 +1,153 @@
+namespace DotNetToolkit.Repository.Utility
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Reflection;
+
+    internal static class FastActivator
+    {
+        #region Fields
+
+        private readonly static ConcurrentDictionary<Tuple<Type, Type[]>, ObjectActivator> _cache = 
+            new ConcurrentDictionary<Tuple<Type, Type[]>, ObjectActivator>(
+                new TupleComparer());
+
+        #endregion
+
+        #region Delegates
+
+        private delegate object ObjectActivator(params object[] args);
+
+        #endregion
+
+        #region Private Methods
+
+        private static ObjectActivator GetActivator(ConstructorInfo ctor)
+        {
+            return (ObjectActivator)GetActivatorDelegate(typeof(ObjectActivator), ctor);
+        }
+
+        private static Delegate GetActivatorDelegate(Type activatorDelegateType, ConstructorInfo ctor)
+        {
+            var paramsInfo = ctor.GetParameters();
+
+            var param = Expression.Parameter(typeof(object[]), "args");
+
+            var argsExp = new Expression[paramsInfo.Length];
+
+            for (int i = 0; i < paramsInfo.Length; i++)
+            {
+                Expression index = Expression.Constant(i);
+                var paramType = paramsInfo[i].ParameterType;
+
+                Expression paramAccessorExp = Expression.ArrayIndex(param, index);
+
+                Expression paramCastExp = Expression.Convert(paramAccessorExp, paramType);
+
+                argsExp[i] = paramCastExp;
+            }
+
+            var newExp = Expression.New(ctor, argsExp);
+
+            var lambda = Expression.Lambda(activatorDelegateType, newExp, param);
+
+            return lambda.Compile();
+        }
+
+        private static ConstructorInfo GetMatchingConstructor(Type type, object[] args, out Type[] types)
+        {
+            types = (
+                from arg in args
+                where arg != null
+                select arg.GetType()
+                ).ToArray();
+
+            return type.GetConstructor(types);
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        public static object CreateInstance(Type type, params object[] args)
+        {
+            if (type.GetTypeInfo().IsValueType)
+            {
+                return Activator.CreateInstance(type, args);
+            }
+
+            var ctor = GetMatchingConstructor(type, args, out var argTypes);
+            if (ctor == null)
+            {
+                if (args == null || args.Length == 0)
+                {
+                    throw new InvalidOperationException(
+                        string.Format("No default constructor exists for class {0}", type.FullName));
+                }
+
+                throw new InvalidOperationException(
+                    string.Format("No matching constructor found for class {0}", type.FullName));
+            }
+
+            var key = Tuple.Create(type, argTypes);
+            if (!_cache.TryGetValue(key, out var activator))
+            {
+                activator = GetActivator(ctor);
+
+                _cache[key] = activator;
+            }
+
+            return activator(args);
+        }
+
+        public static T CreateInstance<T>(params object[] args)
+        {
+            return (T)CreateInstance(typeof(T), args);
+        }
+
+        #endregion
+
+        #region Nested Type: TupleComparer
+
+        class TupleComparer : IEqualityComparer<Tuple<Type, Type[]>>
+        {
+            public bool Equals(object[] x, object[] y)
+            {
+                return x.Length == y.Length && Enumerable.SequenceEqual(x, y);
+            }
+
+            public bool Equals(Tuple<Type, Type[]> x, Tuple<Type, Type[]> y)
+            {
+                return x.Item1 == y.Item1 && Enumerable.SequenceEqual(x.Item2, y.Item2);
+            }
+
+            public int GetHashCode(object[] o)
+            {
+                var result = o.Aggregate((a, b) => a.GetHashCode() ^ b.GetHashCode());
+                return result != null ? result.GetHashCode() : 0;
+            }
+
+            public int GetHashCode(Tuple<Type, Type[]> o)
+            {
+                unchecked
+                {
+                    int hash = 17;
+
+                    hash = hash * 23 + o.Item1.GetHashCode();
+
+                    foreach (var item in o.Item2)
+                    {
+                        hash = hash * 23 + ((item != null) ? item.GetHashCode() : 0);
+                    }
+
+                    return hash;
+                }
+            }
+        }
+
+        #endregion
+    }
+}