Merge pull request #5 from servicetitan/supporting-open-generic

Add non-generic overload of CreateInstance

Author: hypercodeplace

LazyProxy.Tests/LazyProxyBuilderTests.cs

@@ -363,6 +363,37 @@ public void GenericInterfacesMustBeProxied()
             Assert.Equal(expectedResult2, actualResult2);
         }
 
+        [Fact]
+        public void GenericInterfacesMustBeProxiedByNonGenericMethod()
+        {
+            var arg1 = new TestArgument2();
+            var arg2 = new TestArgument();
+            var expectedResult1 = new TestArgument4();
+            var expectedResult2 = new TestArgument2();
+
+            var proxyObject = LazyProxyBuilder.CreateInstance(
+                typeof(IGenericTestService<TestArgument2, TestArgument, TestArgument4>), () =>
+                {
+                    var mock = new Mock<IGenericTestService<TestArgument2, TestArgument, TestArgument4>>(
+                        MockBehavior.Strict);
+
+                    mock.Setup(s => s.Method1(arg1, arg2)).Returns(expectedResult1);
+                    mock.Setup(s => s.Method2(arg1, arg2)).Returns(expectedResult2);
+
+                    return mock.Object;
+                });
+
+            var proxy = proxyObject as IGenericTestService<TestArgument2, TestArgument, TestArgument4>;
+
+            Assert.NotNull(proxy);
+
+            var actualResult1 = proxy.Method1(arg1, arg2);
+            var actualResult2 = proxy.Method2(arg1, arg2);
+
+            Assert.Equal(expectedResult1, actualResult1);
+            Assert.Equal(expectedResult2, actualResult2);
+        }
+
         [Fact]
         public void GenericInterfaceWithDifferentTypeParametersMustBeCreatedWithoutExceptions()
         {

LazyProxy/LazyBuilder.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace LazyProxy
+{
+    /// <summary>
+    /// This type hosts factory method that creates <see cref="Lazy{T}"/> instances.
+    /// </summary>
+    public static class LazyBuilder
+    {
+        /// <summary>
+        /// Creates an instance of <see cref="Lazy{T}"/>.
+        /// </summary>
+        /// <param name="valueFactory">Function that returns a value.</param>
+        /// <typeparam name="T">Type of lazy value.</typeparam>
+        /// <returns>Instance of <see cref="Lazy{T}"/></returns>
+        public static Lazy<T> CreateInstance<T>(Func<object> valueFactory)
+        {
+            return new Lazy<T>(() => (T) valueFactory());
+        }
+    }
+}

LazyProxy/LazyProxyBase.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace LazyProxy
+{
+    /// <summary>
+    /// Base class for lazy proxies.
+    /// </summary>
+    public abstract class LazyProxyBase
+    {
+        /// <summary>
+        /// Initializes inner <see cref="Lazy{T}"/> instance with the valueFactory provided.
+        /// </summary>
+        /// <param name="valueFactory">Function that returns a value.</param>
+        public abstract void Initialize(Func<object> valueFactory);
+    }
+}

LazyProxy/LazyProxyBuilder.cs

@@ -25,13 +25,16 @@ public static class LazyProxyBuilder
         private static readonly ConcurrentDictionary<Type, Lazy<Type>> ProxyTypes =
             new ConcurrentDictionary<Type, Lazy<Type>>();
 
+        private static readonly MethodInfo CreateLazyMethod = typeof(LazyBuilder)
+            .GetMethod("CreateInstance", BindingFlags.Public | BindingFlags.Static);
+
         /// <summary>
         /// Defines at runtime a class that implements interface T
         /// and proxies all invocations to <see cref="Lazy{T}"/> of this interface.
         /// </summary>
         /// <typeparam name="T">The interface proxy type implements.</typeparam>
         /// <returns>The lazy proxy type.</returns>
-        public static Type GetType<T>()
+        public static Type GetType<T>() where T : class
         {
             return GetType(typeof(T));
         }
@@ -50,10 +53,18 @@ public static Type GetType(Type type)
                 throw new NotSupportedException("The lazy proxy is supported only for interfaces.");
             }
 
+            var interfaceType = type.IsConstructedGenericType
+                ? type.GetGenericTypeDefinition()
+                : type;
+
             // Lazy is used to guarantee the valueFactory is invoked only once.
             // More info: http://reedcopsey.com/2011/01/16/concurrentdictionarytkeytvalue-used-with-lazyt/
-            var lazy = ProxyTypes.GetOrAdd(type, t => new Lazy<Type>(() => DefineProxyType(t)));
-            return lazy.Value;
+            var lazy = ProxyTypes.GetOrAdd(interfaceType, t => new Lazy<Type>(() => DefineProxyType(t)));
+            var proxyType = lazy.Value;
+
+            return type.IsConstructedGenericType
+                ? proxyType.MakeGenericType(type.GetGenericArguments())
+                : proxyType;
         }
 
         /// <summary>
@@ -62,11 +73,27 @@ public static Type GetType(Type type)
         /// <param name="valueFactory">The function real value returns.</param>
         /// <typeparam name="T">The interface proxy type implements.</typeparam>
         /// <returns>The lazy proxy type instance.</returns>
-        public static T CreateInstance<T>(Func<T> valueFactory)
+        public static T CreateInstance<T>(Func<T> valueFactory) where T : class
         {
-            var lazy = new Lazy<T>(valueFactory);
-            var proxyType = GetType<T>();
-            return (T) Activator.CreateInstance(proxyType, lazy);
+            return (T) CreateInstance(typeof(T), valueFactory);
+        }
+
+        /// <summary>
+        /// Creates a lazy proxy type instance using a value factory.
+        /// </summary>
+        /// <param name="type">The interface proxy type implements.</param>
+        /// <param name="valueFactory">The function real value returns.</param>
+        /// <returns>The lazy proxy type instance.</returns>
+        public static object CreateInstance(Type type, Func<object> valueFactory)
+        {
+            var proxyType = GetType(type);
+
+            // Using 'Initialize' method after the instance creation allows to improve performance
+            // because Activator.CreateInstance executed with arguments is much slower.
+            var instance = (LazyProxyBase) Activator.CreateInstance(proxyType);
+            instance.Initialize(valueFactory);
+
+            return instance;
         }
 
         /// <summary>
@@ -81,9 +108,9 @@ public static T CreateInstance<T>(Func<T> valueFactory)
         /// {
         ///     private Lazy<IMyService> _service;
         ///
-        ///     public LazyProxyImpl_1eb94ccd79fd48af8adfbc97c76c10ff_IMyService(Lazy<IMyService> service)
+        ///     public void Initialize(Func<object> valueFactory)
         ///     {
-        ///         _service = service;
+        ///         _service = LazyBuilder.CreateInstance<IMyService>(valueFactory);
         ///     }
         ///
         ///     public void Foo() => _service.Value.Foo();
@@ -101,11 +128,11 @@ private static Type DefineProxyType(Type type)
 
             var typeName = $"{type.Namespace}.{LazyProxyTypeSuffix}_{guid}_{type.Name}";
 
-            return ModuleBuilder.DefineType(typeName, TypeAttributes.Public)
+            return ModuleBuilder.DefineType(typeName, TypeAttributes.Public, typeof(LazyProxyBase))
                 .AddGenericParameters(type)
                 .AddInterface(type)
                 .AddServiceField(type, out var serviceField)
-                .AddConstructor(type, serviceField)
+                .AddInitializeMethod(type, serviceField)
                 .AddMethods(type, serviceField)
                 .CreateTypeInfo();
         }
@@ -137,18 +164,22 @@ private static TypeBuilder AddServiceField(this TypeBuilder typeBuilder,
             return typeBuilder;
         }
 
-        private static TypeBuilder AddConstructor(this TypeBuilder typeBuilder, Type type, FieldInfo serviceField)
+        private static TypeBuilder AddInitializeMethod(this TypeBuilder typeBuilder, Type type, FieldInfo serviceField)
         {
-            var constructorBuilder = typeBuilder.DefineConstructor(
-                MethodAttributes.Public,
-                CallingConventions.Standard,
-                new[] {typeof(Lazy<>).MakeGenericType(type)}
+            var methodBuilder = typeBuilder.DefineMethod(
+                "Initialize",
+                MethodAttributes.Public | MethodAttributes.Virtual,
+                null,
+                new [] { typeof(Func<object>) }
             );
 
-            var generator = constructorBuilder.GetILGenerator();
+            var createLazyMethod = CreateLazyMethod.MakeGenericMethod(type);
+
+            var generator = methodBuilder.GetILGenerator();
 
             generator.Emit(OpCodes.Ldarg_0);
             generator.Emit(OpCodes.Ldarg_1);
+            generator.Emit(OpCodes.Call, createLazyMethod);
             generator.Emit(OpCodes.Stfld, serviceField);
             generator.Emit(OpCodes.Ret);