Explicitly implement INHibernateProxy

Author: hazzik

src/NHibernate/Proxy/DefaultProxyFactory.cs

@@ -18,7 +18,7 @@ public override INHibernateProxy GetProxy(object id, ISessionImplementor session
 
 				object proxyInstance = IsClassProxy
 										? factory.CreateProxy(PersistentClass, initializer, Interfaces)
-										: factory.CreateProxy(Interfaces[0], initializer, Interfaces);
+										: factory.CreateProxy(typeof(object), initializer, Interfaces);
 
 				return (INHibernateProxy) proxyInstance;
 			}
@@ -35,4 +35,4 @@ public override object GetFieldInterceptionProxy(object instanceToWrap)
 			return factory.CreateProxy(PersistentClass, interceptor, new[] { typeof(IFieldInterceptorAccessor) });
 		}
 	}
-}
+}

src/NHibernate/Proxy/DynamicProxy/NHibernateProxyImplementor.cs

@@ -0,0 +1,38 @@
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace NHibernate.Proxy.DynamicProxy
+{
+	class NHibernateProxyImplementor
+	{
+		const MethodAttributes InterceptorMethodsAttributes = MethodAttributes.Private | MethodAttributes.Final | MethodAttributes.HideBySig |
+		                                                      MethodAttributes.SpecialName | MethodAttributes.NewSlot | MethodAttributes.Virtual;
+
+		const string HibernateLazyInitializerFieldName = nameof(INHibernateProxy.HibernateLazyInitializer);
+
+		static readonly System.Type ReturnType = typeof(ILazyInitializer);
+		static readonly System.Type NHibernateProxyType = typeof(INHibernateProxy);
+		static readonly PropertyInfo OriginalGetter = NHibernateProxyType.GetProperty(HibernateLazyInitializerFieldName);
+		static readonly MethodInfo OriginalGetterGetMethod = OriginalGetter.GetMethod;
+
+		public static void ImplementProxy(TypeBuilder typeBuilder, FieldInfo interceptor)
+		{
+			// Implement the getter
+			var getMethod = typeBuilder.DefineMethod($"{NHibernateProxyType.FullName}.get_{HibernateLazyInitializerFieldName}", InterceptorMethodsAttributes, CallingConventions.HasThis, ReturnType, System.Type.EmptyTypes);
+			getMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL);
+
+			var IL = getMethod.GetILGenerator();
+
+			// This is equivalent to:
+			// get { return (INHibernateProxy)__interceptor; }
+			IL.Emit(OpCodes.Ldarg_0);
+			IL.Emit(OpCodes.Ldfld, interceptor);
+			IL.Emit(OpCodes.Castclass, ReturnType);
+			IL.Emit(OpCodes.Ret);
+
+			typeBuilder.DefineMethodOverride(getMethod, OriginalGetterGetMethod);
+			var property = typeBuilder.DefineProperty($"{NHibernateProxyType.FullName}.{HibernateLazyInitializerFieldName}", OriginalGetter.Attributes, ReturnType, System.Type.EmptyTypes);
+			property.SetGetMethod(getMethod);
+		}
+	}
+}

src/NHibernate/Proxy/DynamicProxy/ProxyDummy.cs

@@ -6,10 +6,14 @@
 
 #endregion
 
+using System;
+
 namespace NHibernate.Proxy.DynamicProxy
 {
+	//Since v5.1
+	[Obsolete]
 	public class ProxyDummy
 	{
 		/* No Implementation */
 	}
-}
+}

src/NHibernate/Proxy/DynamicProxy/ProxyFactory.cs

@@ -109,12 +109,6 @@ private TypeInfo CreateUncachedProxyType(System.Type baseType, System.Type[] bas
 
 			// Use the proxy dummy as the base type 
 			// since we're not inheriting from any class type
-			System.Type parentType = baseType;
-			if (baseType.IsInterface)
-			{
-				parentType = typeof (ProxyDummy);
-				interfaces.Add(baseType);
-			}
 
 			// Add any inherited interfaces
 			System.Type[] computedInterfaces = interfaces.ToArray();
@@ -126,23 +120,29 @@ private TypeInfo CreateUncachedProxyType(System.Type baseType, System.Type[] bas
 			// Add the ISerializable interface so that it can be implemented
 			interfaces.Add(typeof (ISerializable));
 
-			TypeBuilder typeBuilder = moduleBuilder.DefineType(typeName, typeAttributes, parentType, interfaces.ToArray());
+			TypeBuilder typeBuilder = moduleBuilder.DefineType(typeName, typeAttributes, baseType, interfaces.ToArray());
 
-			ConstructorBuilder defaultConstructor = DefineConstructor(typeBuilder, parentType);
+			ConstructorBuilder defaultConstructor = DefineConstructor(typeBuilder, baseType);
 
 			// Implement IProxy
 			var implementor = new ProxyImplementor();
 			implementor.ImplementProxy(typeBuilder);
 
 			FieldInfo interceptorField = implementor.InterceptorField;
+
 
 			// Provide a custom implementation of ISerializable
 			// instead of redirecting it back to the interceptor
-			foreach (MethodInfo method in GetProxiableMethods(baseType, interfaces).Where(method => method.DeclaringType != typeof(ISerializable)))
+			foreach (MethodInfo method in GetProxiableMethods(baseType, interfaces.Except(new[] {typeof(ISerializable), typeof(INHibernateProxy)})))
 			{
 				ProxyMethodBuilder.CreateProxiedMethod(interceptorField, method, typeBuilder);
 			}
 
+			if (interfaces.Contains(typeof(INHibernateProxy)))
+			{
+				NHibernateProxyImplementor.ImplementProxy(typeBuilder, interceptorField);
+			}
+
 			// Make the proxy serializable
 			AddSerializationSupport(baseType, baseInterfaces, typeBuilder, interceptorField, defaultConstructor);
 			TypeInfo proxyType = typeBuilder.CreateTypeInfo();
@@ -304,4 +304,4 @@ private static void AddSerializationSupport(System.Type baseType, System.Type[]
 			ImplementGetObjectData(baseType, baseInterfaces, typeBuilder, interceptorField);
 		}
 	}
-}
+}

src/NHibernate/Proxy/Poco/BasicLazyInitializer.cs

@@ -81,10 +81,6 @@ public virtual object Invoke(MethodInfo method, object[] args, object proxy)
 				{
 					return null;
 				}
-				else if ("get_HibernateLazyInitializer".Equals(methodName))
-				{
-					return this;
-				}
 			}
 			else if (paramCount == 1)
 			{