Merge pull request #4 from servicetitan/generic-interfaces-without-type-parameters

Add supporting of generic interfaces without type parameters

Author: hypercodeplace

LazyProxy.Tests/LazyProxyBuilderTests.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using System.Threading.Tasks;
 using Moq;
 using Xunit;
@@ -8,13 +7,21 @@ namespace LazyProxy.Tests
 {
     public class LazyProxyBuilderTests
     {
-        public class TestArgument { }
+        public interface IBaseArgument { }
+
+        public abstract class BaseArgument : IBaseArgument { }
+
+        public abstract class BaseArgument2 { }
+
+        public struct TestArgument : IBaseArgument { }
 
         // ReSharper disable once MemberCanBePrivate.Global
-        public class TestArgument2 { }
+        public class TestArgument2 : BaseArgument { }
 
         // ReSharper disable once MemberCanBePrivate.Global
-        public class TestArgument3 { }
+        public class TestArgument3 : BaseArgument { }
+
+        public class TestArgument4 : BaseArgument2, IBaseArgument { }
 
         private class TestException : Exception { }
 
@@ -37,14 +44,21 @@ public interface ITestService : IParentTestService
             string MethodWithDefaultValue(string arg = "arg");
             string MethodWithOutValue(out string arg);
             string MethodWithRefValue(ref TestArgument arg);
-            string GenericMethod<T1, T2>(string arg);
+            string GenericMethod<T1, T2, T3>(string arg)
+                where T1 : class, IBaseArgument, new()
+                where T2 : struct
+                where T3 : BaseArgument2, IBaseArgument;
         }
 
         // ReSharper disable once MemberCanBePrivate.Global
         public interface IGenericTestService<T, in TIn, out TOut>
+            where T : class, IBaseArgument, new()
+            where TIn : struct
+            where TOut : BaseArgument2, IBaseArgument
         {
             TOut Method1(T arg1, TIn arg2);
             T Method2(T arg1, TIn arg2);
+            T GenericMethod<T1, T2>(TIn arg);
         }
 
         // ReSharper disable once UnusedMember.Global
@@ -55,7 +69,7 @@ public void ProxyMustImplementInterface()
         {
             var proxyType = LazyProxyBuilder.BuildLazyProxyType<ITestService>();
 
-            Assert.True(proxyType.GetInterfaces().Contains(typeof(ITestService)));
+            Assert.Contains(typeof(ITestService), proxyType.GetInterfaces());
         }
 
         [Fact]
@@ -211,12 +225,14 @@ public void GenericMethodsMustBeProxied()
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
-                mock.Setup(s => s.GenericMethod<TestArgument, TestException>(arg)).Returns(expectedResult);
+                mock
+                    .Setup(s => s.GenericMethod<TestArgument2, TestArgument, TestArgument4>(arg))
+                    .Returns(expectedResult);
 
                 return mock.Object;
             });
 
-            var actualResult = proxy.GenericMethod<TestArgument, TestException>(arg);
+            var actualResult = proxy.GenericMethod<TestArgument2, TestArgument, TestArgument4>(arg);
 
             Assert.Equal(expectedResult, actualResult);
         }
@@ -325,14 +341,14 @@ public void ExceptionsFromServiceMustBeThrown()
         [Fact]
         public void GenericInterfacesMustBeProxied()
         {
-            var arg1 = new TestArgument();
-            var arg2 = new TestArgument2();
-            var expectedResult1 = new TestArgument3();
-            var expectedResult2 = new TestArgument();
+            var arg1 = new TestArgument2();
+            var arg2 = new TestArgument();
+            var expectedResult1 = new TestArgument4();
+            var expectedResult2 = new TestArgument2();
 
             var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
             {
-                var mock = new Mock<IGenericTestService<TestArgument, TestArgument2, TestArgument3>>(MockBehavior.Strict);
+                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);
@@ -352,8 +368,10 @@ public void GenericInterfaceWithDifferentTypeParametersMustBeCreatedWithoutExcep
         {
             var exception = Record.Exception(() =>
             {
-                LazyProxyBuilder.BuildLazyProxyType<IGenericTestService<TestArgument, TestArgument2, TestArgument3>>();
-                LazyProxyBuilder.BuildLazyProxyType<IGenericTestService<TestArgument3, TestArgument, TestArgument2>>();
+                LazyProxyBuilder.BuildLazyProxyType(typeof(IGenericTestService<,,>));
+                LazyProxyBuilder.BuildLazyProxyType<IGenericTestService<TestArgument2, TestArgument, TestArgument4>>();
+                LazyProxyBuilder.BuildLazyProxyType<IGenericTestService<TestArgument3, TestArgument, TestArgument4>>();
+
             });
 
             Assert.Null(exception);

LazyProxy/LazyProxyBuilder.cs

@@ -91,7 +91,7 @@ public static T CreateLazyProxyInstance<T>(Func<T> valueFactory)
         ///
         /// ]]>
         /// </summary>
-        /// <typeparam name="T">The interface proxy type implements.</typeparam>
+        /// <param name="type">The interface proxy type implements.</param>
         /// <returns>The lazy proxy type.</returns>
         private static Type DefineProxyType(Type type)
         {
@@ -102,13 +102,24 @@ private static Type DefineProxyType(Type type)
             var typeName = $"{type.Namespace}.{LazyProxyTypeSuffix}_{guid}_{type.Name}";
 
             return ModuleBuilder.DefineType(typeName, TypeAttributes.Public)
+                .AddGenericParameters(type)
                 .AddInterface(type)
                 .AddServiceField(type, out var serviceField)
                 .AddConstructor(type, serviceField)
                 .AddMethods(type, serviceField)
                 .CreateTypeInfo();
         }
 
+        private static TypeBuilder AddGenericParameters(this TypeBuilder typeBuilder, Type type)
+        {
+            if (type.IsGenericTypeDefinition)
+            {
+                AddGenericParameters(type.GetGenericArguments, typeBuilder.DefineGenericParameters);
+            }
+
+            return typeBuilder;
+        }
+
         private static TypeBuilder AddInterface(this TypeBuilder typeBuilder, Type type)
         {
             typeBuilder.AddInterfaceImplementation(type);
@@ -164,11 +175,7 @@ private static TypeBuilder AddMethods(this TypeBuilder typeBuilder, Type type, F
 
                 if (method.IsGenericMethod)
                 {
-                    var genericTypeNames = method.GetGenericArguments()
-                        .Select(genericType => genericType.Name)
-                        .ToArray();
-
-                    methodBuilder.DefineGenericParameters(genericTypeNames);
+                    AddGenericParameters(method.GetGenericArguments, methodBuilder.DefineGenericParameters);
                 }
 
                 var generator = methodBuilder.GetILGenerator();
@@ -206,5 +213,43 @@ private static MethodInfo GetGetServiceValueMethod(FieldInfo serviceField)
             // ReSharper disable once PossibleNullReferenceException
             return serviceField.FieldType.GetProperty("Value").GetGetMethod(true);
         }
+
+        private static void AddGenericParameters(
+            Func<IReadOnlyList<Type>> getGenericParameters,
+            Func<string[], IReadOnlyList<GenericTypeParameterBuilder>> defineGenericParameters)
+        {
+            var genericParameters = getGenericParameters();
+
+            var genericParametersNames = genericParameters
+                .Select(genericType => genericType.Name)
+                .ToArray();
+
+            var definedGenericParameters = defineGenericParameters(genericParametersNames);
+
+            for (var i = 0; i < genericParameters.Count; i++)
+            {
+                var genericParameter = genericParameters[i];
+                var definedGenericParameter = definedGenericParameters[i];
+                var genericParameterAttributes = genericParameter.GenericParameterAttributes
+                                                 & ~GenericParameterAttributes.Covariant
+                                                 & ~GenericParameterAttributes.Contravariant;
+
+                definedGenericParameter.SetGenericParameterAttributes(genericParameterAttributes);
+
+                var genericParameterConstraints = genericParameter.GetGenericParameterConstraints();
+
+                foreach (var constraint in genericParameterConstraints)
+                {
+                    if (constraint.IsInterface)
+                    {
+                        definedGenericParameter.SetInterfaceConstraints(constraint);
+                    }
+                    else
+                    {
+                        definedGenericParameter.SetBaseTypeConstraint(constraint);
+                    }
+                }
+            }
+        }
     }
 }