Pre-calculate IsClassProxy by PocoEntityTuplizer

hazzik · hazzik · commit b20f638fbbb1 · 2019-03-20T09:50:20.000+13:00
diff --git a/src/NHibernate.Test/NHSpecificTest/GH2067/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/GH2067/Fixture.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Mapping.ByCode;
+using NHibernate.Proxy;
 using NUnit.Framework;
 
 namespace NHibernate.Test.NHSpecificTest.GH2067
@@ -65,9 +66,11 @@ public void CanLoadDomesticCatUsingBaseClass()
 				var domesticCat = (IDomesticCat) cat;
 				Assert.That(domesticCat.Name, Is.EqualTo("Tom"));
 				Assert.That(domesticCat.OwnerName, Is.EqualTo("Jerry"));
+				var proxy = (INHibernateProxy) cat;
+				Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(Cat)));
 			}
 		}
-		
+
 		[Test]
 		public void CanLoadDomesticCatUsingBaseClassInterface()
 		{
@@ -80,6 +83,8 @@ public void CanLoadDomesticCatUsingBaseClassInterface()
 				var domesticCat = (IDomesticCat) cat;
 				Assert.That(domesticCat.Name, Is.EqualTo("Tom"));
 				Assert.That(domesticCat.OwnerName, Is.EqualTo("Jerry"));
+				var proxy = (INHibernateProxy) cat;
+				Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(Cat)));
 			}
 		}
 
@@ -93,6 +98,8 @@ public void CanLoadDomesticCatUsingInterface()
 				Assert.That(cat, Is.Not.Null);
 				Assert.That(cat.Name, Is.EqualTo("Tom"));
 				Assert.That(cat.OwnerName, Is.EqualTo("Jerry"));
+				var proxy = (INHibernateProxy) cat;
+				Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(DomesticCat)));
 			}
 		}
 
@@ -116,6 +123,8 @@ public void CanLoadDomesticCatUsingSealedClass()
 				Assert.That(cat, Is.Not.Null);
 				Assert.That(cat.Name, Is.EqualTo("Tom"));
 				Assert.That(cat.OwnerName, Is.EqualTo("Jerry"));
+				var proxy = (INHibernateProxy) cat;
+				Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(DomesticCat)));
 			}
 		}
 
@@ -128,6 +137,8 @@ public void CanLoadDomesticCatUsingSideInterface()
 				var cat = session.Load<IPet>(domesticCatId);
 				Assert.That(cat, Is.Not.Null);
 				Assert.That(cat.OwnerName, Is.EqualTo("Jerry"));
+				var proxy = (INHibernateProxy) cat;
+				Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(DomesticCat)));
 			}
 		}
 
@@ -140,6 +151,8 @@ public void CanLoadCatUsingClass()
 				var cat = session.Load<Cat>(catId);
 				Assert.That(cat, Is.Not.Null);
 				Assert.That(cat.Name, Is.EqualTo("Bob"));
+				var proxy = (INHibernateProxy) cat;
+				Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(Cat)));
 			}
 		}
 		
@@ -152,6 +165,8 @@ public void CanLoadCatUsingInterface()
 				var cat = session.Load<ICat>(catId);
 				Assert.That(cat, Is.Not.Null);
 				Assert.That(cat.Name, Is.EqualTo("Bob"));
+				var proxy = (INHibernateProxy) cat;
+				Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(Cat)));
 			}
 		}
 	}
diff --git a/src/NHibernate/Proxy/AbstractProxyFactory.cs b/src/NHibernate/Proxy/AbstractProxyFactory.cs
@@ -19,11 +19,7 @@ public abstract class AbstractProxyFactory: IProxyFactory
 		protected virtual MethodInfo SetIdentifierMethod { get; private set; }
 		protected virtual IAbstractComponentType ComponentIdType { get; private set; }
 		protected virtual bool OverridesEquals { get; set; }
-
-		protected bool IsClassProxy
-		{
-			get { return Interfaces.Length == 1; }
-		}
+		protected internal bool IsClassProxy { get; internal set; }
 
 		public virtual void PostInstantiate(string entityName, System.Type persistentClass, ISet<System.Type> interfaces,
 																				MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod,
@@ -44,7 +40,6 @@ public virtual void PostInstantiate(string entityName, System.Type persistentCla
 			OverridesEquals = ReflectHelper.OverridesEquals(persistentClass);
 		}
 
-
 		public abstract INHibernateProxy GetProxy(object id, ISessionImplementor session);
 
 		// Since 5.3
diff --git a/src/NHibernate/Proxy/NHibernateProxyFactoryInfo.cs b/src/NHibernate/Proxy/NHibernateProxyFactoryInfo.cs
@@ -16,22 +16,32 @@ public sealed class NHibernateProxyFactoryInfo : ISerializable
 		private readonly MethodInfo _getIdentifierMethod;
 		private readonly MethodInfo _setIdentifierMethod;
 		private readonly IAbstractComponentType _componentIdType;
+		private readonly bool _isClassProxy;
 
-		internal NHibernateProxyFactoryInfo(string entityName, System.Type persistentClass, System.Type[] interfaces, MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod, IAbstractComponentType componentIdType)
+		internal NHibernateProxyFactoryInfo(
+			string entityName,
+			System.Type persistentClass,
+			System.Type[] interfaces,
+			MethodInfo getIdentifierMethod,
+			MethodInfo setIdentifierMethod,
+			IAbstractComponentType componentIdType,
+			bool isClassProxy)
 		{
 			_entityName = entityName;
 			_persistentClass = persistentClass;
 			_interfaces = interfaces;
 			_getIdentifierMethod = getIdentifierMethod;
 			_setIdentifierMethod = setIdentifierMethod;
 			_componentIdType = componentIdType;
+			_isClassProxy = isClassProxy;
 		}
 
 		internal System.Type PersistentClass => _persistentClass;
 
 		public IProxyFactory CreateProxyFactory()
 		{
 			var factory = new StaticProxyFactory();
+			factory.IsClassProxy = _isClassProxy;
 			factory.PostInstantiate(_entityName, _persistentClass, new HashSet<System.Type>(_interfaces), _getIdentifierMethod, _setIdentifierMethod, _componentIdType);
 			return factory;
 		}
@@ -44,6 +54,7 @@ private NHibernateProxyFactoryInfo(SerializationInfo info, StreamingContext cont
 			_getIdentifierMethod = (MethodInfo) info.GetValue(nameof(_getIdentifierMethod), typeof(MethodInfo));
 			_setIdentifierMethod = (MethodInfo) info.GetValue(nameof(_setIdentifierMethod), typeof(MethodInfo));
 			_componentIdType = (IAbstractComponentType) info.GetValue(nameof(_componentIdType), typeof(IAbstractComponentType));
+			_isClassProxy = (bool) info.GetValue(nameof(_isClassProxy), typeof(bool));
 		}
 
 		[SecurityCritical]
@@ -55,6 +66,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context)
 			info.AddValue(nameof(_getIdentifierMethod), _getIdentifierMethod);
 			info.AddValue(nameof(_setIdentifierMethod), _setIdentifierMethod);
 			info.AddValue(nameof(_componentIdType), _componentIdType);
+			info.AddValue(nameof(_isClassProxy), _isClassProxy);
 		}
 	}
 }
diff --git a/src/NHibernate/Proxy/StaticProxyFactory.cs b/src/NHibernate/Proxy/StaticProxyFactory.cs
@@ -53,8 +53,9 @@ public override void PostInstantiate(
 				Interfaces,
 				GetIdentifierMethod,
 				SetIdentifierMethod,
-				ComponentIdType);
-			_cacheEntry = new ProxyCacheEntry(PersistentClass, Interfaces);
+				ComponentIdType,
+				IsClassProxy);
+			_cacheEntry = new ProxyCacheEntry(IsClassProxy ? PersistentClass : typeof(object), Interfaces);
 		}
 
 		private Func<ILazyInitializer, NHibernateProxyFactoryInfo, INHibernateProxy> CreateProxyActivator(ProxyCacheEntry pke)
diff --git a/src/NHibernate/Tuple/Entity/PocoEntityTuplizer.cs b/src/NHibernate/Tuple/Entity/PocoEntityTuplizer.cs
@@ -172,9 +172,14 @@ protected override IProxyFactory BuildProxyFactory(PersistentClass persistentCla
 			IProxyFactory pf = BuildProxyFactoryInternal(persistentClass, idGetter, idSetter);
 			try
 			{
+				if (pf is AbstractProxyFactory apf)
+				{
+					apf.IsClassProxy = !isInterface;
+				}
+				
 				pf.PostInstantiate(
 					EntityName,
-					isInterface ? typeof(object) : _mappedClass,
+					_mappedClass,
 					proxyInterfaces,
 					proxyGetIdentifierMethod,
 					proxySetIdentifierMethod,

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System;`
`2`	`2`	`using NHibernate.Cfg.MappingSchema;`
`3`	`3`	`using NHibernate.Mapping.ByCode;`
	`4`	`+using NHibernate.Proxy;`
`4`	`5`	`using NUnit.Framework;`
`5`	`6`
`6`	`7`	`namespace NHibernate.Test.NHSpecificTest.GH2067`
`@@ -65,9 +66,11 @@ public void CanLoadDomesticCatUsingBaseClass()`
`65`	`66`	`var domesticCat = (IDomesticCat) cat;`
`66`	`67`	`Assert.That(domesticCat.Name, Is.EqualTo("Tom"));`
`67`	`68`	`Assert.That(domesticCat.OwnerName, Is.EqualTo("Jerry"));`
	`69`	`+ var proxy = (INHibernateProxy) cat;`
	`70`	`+ Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(Cat)));`
`68`	`71`	`}`
`69`	`72`	`}`
`70`		`-`
	`73`	`+`
`71`	`74`	`[Test]`
`72`	`75`	`public void CanLoadDomesticCatUsingBaseClassInterface()`
`73`	`76`	`{`
`@@ -80,6 +83,8 @@ public void CanLoadDomesticCatUsingBaseClassInterface()`
`80`	`83`	`var domesticCat = (IDomesticCat) cat;`
`81`	`84`	`Assert.That(domesticCat.Name, Is.EqualTo("Tom"));`
`82`	`85`	`Assert.That(domesticCat.OwnerName, Is.EqualTo("Jerry"));`
	`86`	`+ var proxy = (INHibernateProxy) cat;`
	`87`	`+ Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(Cat)));`
`83`	`88`	`}`
`84`	`89`	`}`
`85`	`90`
`@@ -93,6 +98,8 @@ public void CanLoadDomesticCatUsingInterface()`
`93`	`98`	`Assert.That(cat, Is.Not.Null);`
`94`	`99`	`Assert.That(cat.Name, Is.EqualTo("Tom"));`
`95`	`100`	`Assert.That(cat.OwnerName, Is.EqualTo("Jerry"));`
	`101`	`+ var proxy = (INHibernateProxy) cat;`
	`102`	`+ Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(DomesticCat)));`
`96`	`103`	`}`
`97`	`104`	`}`
`98`	`105`
`@@ -116,6 +123,8 @@ public void CanLoadDomesticCatUsingSealedClass()`
`116`	`123`	`Assert.That(cat, Is.Not.Null);`
`117`	`124`	`Assert.That(cat.Name, Is.EqualTo("Tom"));`
`118`	`125`	`Assert.That(cat.OwnerName, Is.EqualTo("Jerry"));`
	`126`	`+ var proxy = (INHibernateProxy) cat;`
	`127`	`+ Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(DomesticCat)));`
`119`	`128`	`}`
`120`	`129`	`}`
`121`	`130`
`@@ -128,6 +137,8 @@ public void CanLoadDomesticCatUsingSideInterface()`
`128`	`137`	`var cat = session.Load<IPet>(domesticCatId);`
`129`	`138`	`Assert.That(cat, Is.Not.Null);`
`130`	`139`	`Assert.That(cat.OwnerName, Is.EqualTo("Jerry"));`
	`140`	`+ var proxy = (INHibernateProxy) cat;`
	`141`	`+ Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(DomesticCat)));`
`131`	`142`	`}`
`132`	`143`	`}`
`133`	`144`
`@@ -140,6 +151,8 @@ public void CanLoadCatUsingClass()`
`140`	`151`	`var cat = session.Load<Cat>(catId);`
`141`	`152`	`Assert.That(cat, Is.Not.Null);`
`142`	`153`	`Assert.That(cat.Name, Is.EqualTo("Bob"));`
	`154`	`+ var proxy = (INHibernateProxy) cat;`
	`155`	`+ Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(Cat)));`
`143`	`156`	`}`
`144`	`157`	`}`
`145`	`158`
`@@ -152,6 +165,8 @@ public void CanLoadCatUsingInterface()`
`152`	`165`	`var cat = session.Load<ICat>(catId);`
`153`	`166`	`Assert.That(cat, Is.Not.Null);`
`154`	`167`	`Assert.That(cat.Name, Is.EqualTo("Bob"));`
	`168`	`+ var proxy = (INHibernateProxy) cat;`
	`169`	`+ Assert.That(proxy.HibernateLazyInitializer.PersistentClass, Is.EqualTo(typeof(Cat)));`
`155`	`170`	`}`
`156`	`171`	`}`
`157`	`172`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,22 +16,32 @@ public sealed class NHibernateProxyFactoryInfo : ISerializable`
`16`	`16`	`private readonly MethodInfo _getIdentifierMethod;`
`17`	`17`	`private readonly MethodInfo _setIdentifierMethod;`
`18`	`18`	`private readonly IAbstractComponentType _componentIdType;`
	`19`	`+ private readonly bool _isClassProxy;`
`19`	`20`
`20`		`- internal NHibernateProxyFactoryInfo(string entityName, System.Type persistentClass, System.Type[] interfaces, MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod, IAbstractComponentType componentIdType)`
	`21`	`+ internal NHibernateProxyFactoryInfo(`
	`22`	`+ string entityName,`
	`23`	`+ System.Type persistentClass,`
	`24`	`+ System.Type[] interfaces,`
	`25`	`+ MethodInfo getIdentifierMethod,`
	`26`	`+ MethodInfo setIdentifierMethod,`
	`27`	`+ IAbstractComponentType componentIdType,`
	`28`	`+ bool isClassProxy)`
`21`	`29`	`{`
`22`	`30`	`_entityName = entityName;`
`23`	`31`	`_persistentClass = persistentClass;`
`24`	`32`	`_interfaces = interfaces;`
`25`	`33`	`_getIdentifierMethod = getIdentifierMethod;`
`26`	`34`	`_setIdentifierMethod = setIdentifierMethod;`
`27`	`35`	`_componentIdType = componentIdType;`
	`36`	`+ _isClassProxy = isClassProxy;`
`28`	`37`	`}`
`29`	`38`
`30`	`39`	`internal System.Type PersistentClass => _persistentClass;`
`31`	`40`
`32`	`41`	`public IProxyFactory CreateProxyFactory()`
`33`	`42`	`{`
`34`	`43`	`var factory = new StaticProxyFactory();`
	`44`	`+ factory.IsClassProxy = _isClassProxy;`
`35`	`45`	`factory.PostInstantiate(_entityName, _persistentClass, new HashSet<System.Type>(_interfaces), _getIdentifierMethod, _setIdentifierMethod, _componentIdType);`
`36`	`46`	`return factory;`
`37`	`47`	`}`
`@@ -44,6 +54,7 @@ private NHibernateProxyFactoryInfo(SerializationInfo info, StreamingContext cont`
`44`	`54`	`_getIdentifierMethod = (MethodInfo) info.GetValue(nameof(_getIdentifierMethod), typeof(MethodInfo));`
`45`	`55`	`_setIdentifierMethod = (MethodInfo) info.GetValue(nameof(_setIdentifierMethod), typeof(MethodInfo));`
`46`	`56`	`_componentIdType = (IAbstractComponentType) info.GetValue(nameof(_componentIdType), typeof(IAbstractComponentType));`
	`57`	`+ _isClassProxy = (bool) info.GetValue(nameof(_isClassProxy), typeof(bool));`
`47`	`58`	`}`
`48`	`59`
`49`	`60`	`[SecurityCritical]`
`@@ -55,6 +66,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context)`
`55`	`66`	`info.AddValue(nameof(_getIdentifierMethod), _getIdentifierMethod);`
`56`	`67`	`info.AddValue(nameof(_setIdentifierMethod), _setIdentifierMethod);`
`57`	`68`	`info.AddValue(nameof(_componentIdType), _componentIdType);`
	`69`	`+ info.AddValue(nameof(_isClassProxy), _isClassProxy);`
`58`	`70`	`}`
`59`	`71`	`}`
`60`	`72`	`}`