DefaultProxyMethodBuilder.cs: Make it better at handling generic methods with various type constraints. Based on pull request #142 from cremor, but leaving out the incomplete parts. Also took the opportunity for some cleanup. NH-3244.

Author: oskarb

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/GenericMethodShouldBeProxied.cs

@@ -1,48 +1,62 @@
-using System.Collections.Generic;
 using NHibernate.Proxy.DynamicProxy;
 using NUnit.Framework;
 using SharpTestsEx;
 
 namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
 {
+	[TestFixture]
 	public class GenericMethodShouldBeProxied
 	{
-		public class MyClass
+		[Test]
+		public void CanProxyBasicGenericMethod()
 		{
-			public virtual object Method<T>()
-			{
-				if(typeof(T) == typeof(int))
-				{
-					return 5;
-				}
-				if (typeof(T) == typeof(string))
-				{
-					return "blha";
-				}
-				return default(T);
-			}
-
-			public virtual TRequestedType As<TRequestedType>() where TRequestedType : MyClass
-			{
-				return this as TRequestedType;
-			}
+			var factory = new ProxyFactory();
+			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
+			c.BasicGenericMethod<int>().Should().Be(5);
+			c.BasicGenericMethod<string>().Should().Be("blha");
 		}
 
 		[Test]
-		public void ProxyOfAGenericMethod()
+		public void CanProxyMethodWithGenericBaseClassConstraint()
 		{
 			var factory = new ProxyFactory();
 			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
-			c.Method<int>().Should().Be(5);
-			c.Method<string>().Should().Be("blha");
+			c.MethodWithGenericBaseClassConstraint<MyGenericClass<int>, int>().Should().Be(typeof(MyGenericClass<int>));
 		}
 
 		[Test]
-		public void ProxyOfSelfCastingMethod()
+		public void CanProxySelfCastingMethod()
 		{
 			var factory = new ProxyFactory();
 			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
 			c.As<MyClass>().Should().Not.Be.Null();
 		}
+
+		[Test]
+		public void CanProxyMethodWithDefaultConstructorConstraint()
+		{
+			var factory = new ProxyFactory();
+			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
+			c.MethodWithConstructorConstraint<MyClass>().Should().Not.Be.Null();
+		}
+
+		[Test]
+		public void CanProxyGenericMethodWithInterfaceConstraint()
+		{
+			var factory = new ProxyFactory();
+			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyClass()), null);
+			c.MethodWithInterfaceConstraint<IMyInterface>().Should().Be(typeof(IMyInterface));
+		}
+
+		[Test]
+		public void CanProxyGenericMethodWithReferenceTypeAndInterfaceConstraint()
+		{
+			var factory = new ProxyFactory();
+			var c = (MyClass)factory.CreateProxy(typeof(MyClass), new PassThroughInterceptor(new MyDerivedClass()), null);
+			c.MethodWithReferenceTypeAndInterfaceConstraint<MyDerivedClass>().Should().Not.Be.Null();
+		}
+
+		class MyDerivedClass : MyClass, IMyInterface
+		{ }
 	}
 }

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/IMyGenericInterface.cs

@@ -0,0 +1,6 @@
+namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
+{
+	public interface IMyGenericInterface<TId>
+	{
+	}
+}

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/IMyInterface.cs

@@ -0,0 +1,6 @@
+namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
+{
+	public interface IMyInterface
+	{
+	}
+}

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/MyClass.cs

@@ -0,0 +1,41 @@
+namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
+{
+	public class MyClass
+	{
+		public virtual object BasicGenericMethod<T>()
+		{
+			if (typeof(T) == typeof(int))
+				return 5;
+
+			if (typeof(T) == typeof(string))
+				return "blha";
+
+			return default(T);
+		}
+
+		public virtual object MethodWithGenericBaseClassConstraint<T, TY>() where T : MyGenericClass<TY>
+		{
+			return typeof(T);
+		}
+
+		public virtual object MethodWithInterfaceConstraint<T>() where T : IMyInterface
+		{
+			return typeof(T);
+		}
+
+		public virtual TRequestedType As<TRequestedType>() where TRequestedType : MyClass
+		{
+			return this as TRequestedType;
+		}
+
+		public virtual TRequestedType MethodWithConstructorConstraint<TRequestedType>() where TRequestedType : new()
+		{
+			return new TRequestedType();
+		}
+
+		public virtual TRequestedType MethodWithReferenceTypeAndInterfaceConstraint<TRequestedType>() where TRequestedType : class, IMyInterface
+		{
+			return this as TRequestedType;
+		}
+	}
+}

src/NHibernate.Test/DynamicProxyTests/GenericMethodsTests/MyGenericClass.cs

@@ -0,0 +1,15 @@
+namespace NHibernate.Test.DynamicProxyTests.GenericMethodsTests
+{
+	public class MyGenericClass<TId> : IMyGenericInterface<TId>
+	{
+		public virtual TRequestedType As<TRequestedType>() where TRequestedType : MyGenericClass<TId>
+		{
+			return this as TRequestedType;
+		}
+
+		public virtual TRequestedType AsInterface<TRequestedType>() where TRequestedType : class, IMyGenericInterface<TId>
+		{
+			return this as TRequestedType;
+		}
+	}
+}

src/NHibernate.Test/NHibernate.Test.csproj

@@ -226,6 +226,10 @@
     <Compile Include="DriverTest\Sql2008DateTime2Test.cs" />
     <Compile Include="DriverTest\SqlClientDriverFixture.cs" />
     <Compile Include="DriverTest\SqlServerCeDriverFixture.cs" />
+    <Compile Include="DynamicProxyTests\GenericMethodsTests\IMyGenericInterface.cs" />
+    <Compile Include="DynamicProxyTests\GenericMethodsTests\IMyInterface.cs" />
+    <Compile Include="DynamicProxyTests\GenericMethodsTests\MyClass.cs" />
+    <Compile Include="DynamicProxyTests\GenericMethodsTests\MyGenericClass.cs" />
     <Compile Include="DynamicProxyTests\PeVerifyFixture.cs" />
     <Compile Include="DynamicProxyTests\GenericMethodsTests\GenericMethodShouldBeProxied.cs" />
     <Compile Include="DynamicProxyTests\InterfaceProxySerializationTests\IMyProxy.cs" />

src/NHibernate/Proxy/DynamicProxy/DefaultProxyMethodBuilder.cs

@@ -17,7 +17,7 @@ namespace NHibernate.Proxy.DynamicProxy
 {
 	internal class DefaultyProxyMethodBuilder : IProxyMethodBuilder
 	{
-		public DefaultyProxyMethodBuilder() : this(new DefaultMethodEmitter()) {}
+		public DefaultyProxyMethodBuilder() : this(new DefaultMethodEmitter()) { }
 
 		public DefaultyProxyMethodBuilder(IMethodBodyEmitter emitter)
 		{
@@ -43,8 +43,8 @@ public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder
 			ParameterInfo[] parameters = method.GetParameters();
 
 			MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes,
-			                                                       CallingConventions.HasThis, method.ReturnType,
-			                                                       parameters.Select(param => param.ParameterType).ToArray());
+																   CallingConventions.HasThis, method.ReturnType,
+																   parameters.Select(param => param.ParameterType).ToArray());
 
 			System.Type[] typeArgs = method.GetGenericArguments();
 
@@ -61,10 +61,21 @@ public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder
 
 				for (int index = 0; index < typeArgs.Length; index++)
 				{
-					typeArgsBuilder[index].SetInterfaceConstraints(typeArgs[index].GetGenericParameterConstraints());
+					// Copy generic parameter attributes (Covariant, Contravariant, ReferenceTypeConstraint,
+					// NotNullableValueTypeConstraint, DefaultConstructorConstraint).
+					typeArgsBuilder[index].SetGenericParameterAttributes(typeArgs[index].GenericParameterAttributes);
+
+					// Copy generic parameter constraints (class and interfaces).
+					var typeConstraints = typeArgs[index].GetGenericParameterConstraints();
+
+					var baseTypeConstraint = typeConstraints.SingleOrDefault(x => x.IsClass);
+					typeArgsBuilder[index].SetBaseTypeConstraint(baseTypeConstraint);
+
+					var interfaceTypeConstraints = typeConstraints.Where(x => !x.IsClass).ToArray();
+					typeArgsBuilder[index].SetInterfaceConstraints(interfaceTypeConstraints);
 				}
 			}
-			
+
 
 			Debug.Assert(MethodBodyEmitter != null);
 			MethodBodyEmitter.EmitMethodBody(methodBuilder, method, field);