Call BeforeAssemble on InitializeFromCache to allow batch fetching

Author: hazzik

src/NHibernate.Test/CacheTest/BatchableCacheFixture.cs

@@ -1553,8 +1553,31 @@ public void QueryFetchEntityBatchCacheTest(bool clearEntityCacheAfterQuery, bool
 			Assert.That(Sfi.Statistics.QueryCacheHitCount, Is.EqualTo(future ? 2 : 1), "Unexpected cache hit count");
 		}
 
+		[Test]
+		public void CollectionLazyInitializationFromCacheIsBatched()
+		{
+			using (var s = OpenSession())
+			{
+				var readOnly = s.Get<ReadOnly>(s.Query<ReadOnly>().Select(x => x.Id).First());
+				Assert.That(readOnly.Items.Count, Is.EqualTo(6));
+			}
+
+			var itemPersister = Sfi.GetEntityPersister(typeof(ReadOnlyItem).FullName);
+			var itemCache = (BatchableCache) itemPersister.Cache.Cache;
+			itemCache.ClearStatistics();
+
+			using (var s = OpenSession())
+			{
+				var readOnly = s.Get<ReadOnly>(s.Query<ReadOnly>().Select(x => x.Id).First());
+				Assert.That(readOnly.Items.Count, Is.EqualTo(6));
+			}
+
+			// 6 items with batch-size = 4 so 2 GetMany calls are expected 1st call: 4 items + 2nd call: 2 items
+			Assert.That(itemCache.GetMultipleCalls.Count, Is.EqualTo(2));
+		}
+
 		private void AssertMultipleCacheCalls<TEntity>(IEnumerable<int> loadIds,  IReadOnlyList<int> getIds, int idIndex, 
-														int[][] fetchedIdIndexes, int[] putIdIndexes, Func<int, bool> cacheBeforeLoadFn = null)
+		                                               int[][] fetchedIdIndexes, int[] putIdIndexes, Func<int, bool> cacheBeforeLoadFn = null)
 			where TEntity : CacheEntity
 		{
 			var persister = Sfi.GetEntityPersister(typeof(TEntity).FullName);

src/NHibernate/Collection/Generic/PersistentGenericBag.cs

@@ -400,9 +400,16 @@ public override void InitializeFromCache(ICollectionPersister persister, object
 			var array = (object[]) disassembled;
 			var size = array.Length;
 			BeforeInitialize(persister, size);
+
+			var elementType = persister.ElementType;
+			for (int i = 0; i < size; i++)
+			{
+				elementType.BeforeAssemble(array[i], Session);
+			}
+
 			for (var i = 0; i < size; i++)
 			{
-				var element = persister.ElementType.Assemble(array[i], Session, owner);
+				var element = elementType.Assemble(array[i], Session, owner);
 				if (element != null)
 				{
 					_gbag.Add((T) element);

src/NHibernate/Collection/Generic/PersistentGenericIdentifierBag.cs

@@ -75,10 +75,19 @@ public override void InitializeFromCache(ICollectionPersister persister, object
 			object[] array = (object[])disassembled;
 			int size = array.Length;
 			BeforeInitialize(persister, size);
+
+			var identifierType = persister.IdentifierType;
+			var elementType = persister.ElementType;
+			for (int i = 0; i < size; i++)
+			{
+				identifierType.BeforeAssemble(array[i], Session);
+				elementType.BeforeAssemble(array[i + 1], Session);
+			}
+
 			for (int i = 0; i < size; i += 2)
 			{
-				_identifiers[i / 2] = persister.IdentifierType.Assemble(array[i], Session, owner);
-				_values.Add((T) persister.ElementType.Assemble(array[i + 1], Session, owner));
+				_identifiers[i / 2] = identifierType.Assemble(array[i], Session, owner);
+				_values.Add((T) elementType.Assemble(array[i + 1], Session, owner));
 			}
 		}
 

src/NHibernate/Collection/Generic/PersistentGenericList.cs

@@ -160,9 +160,16 @@ public override void InitializeFromCache(ICollectionPersister persister, object
 			object[] array = (object[])disassembled;
 			int size = array.Length;
 			BeforeInitialize(persister, size);
+			
+			var elementType = persister.ElementType;
 			for (int i = 0; i < size; i++)
 			{
-				var element = persister.ElementType.Assemble(array[i], Session, owner);
+				elementType.BeforeAssemble(array[i], Session);
+			}
+
+			for (int i = 0; i < size; i++)
+			{
+				var element = elementType.Assemble(array[i], Session, owner);
 				WrappedList.Add((T) (element ?? DefaultForType));
 			}
 		}

src/NHibernate/Collection/Generic/PersistentGenericMap.cs

@@ -163,10 +163,19 @@ public override void InitializeFromCache(ICollectionPersister persister, object
 			object[] array = (object[])disassembled;
 			int size = array.Length;
 			BeforeInitialize(persister, size);
+			
+			var indexType = persister.IndexType;
+			var elementType = persister.ElementType;
+			for (int i = 0; i < size; i++)
+			{
+				indexType.BeforeAssemble(array[i], Session);
+				elementType.BeforeAssemble(array[i + 1], Session);
+			}
+
 			for (int i = 0; i < size; i += 2)
 			{
-				WrappedMap[(TKey)persister.IndexType.Assemble(array[i], Session, owner)] =
-					(TValue)persister.ElementType.Assemble(array[i + 1], Session, owner);
+				WrappedMap[(TKey)indexType.Assemble(array[i], Session, owner)] =
+					(TValue)elementType.Assemble(array[i + 1], Session, owner);
 			}
 		}
 

src/NHibernate/Collection/Generic/PersistentGenericSet.cs

@@ -154,9 +154,16 @@ public override void InitializeFromCache(ICollectionPersister persister, object
 			var array = (object[])disassembled;
 			int size = array.Length;
 			BeforeInitialize(persister, size);
+
+			var elementType = persister.ElementType;
+			for (int i = 0; i < size; i++)
+			{
+				elementType.BeforeAssemble(array[i], Session);
+			}
+
 			for (int i = 0; i < size; i++)
 			{
-				var element = persister.ElementType.Assemble(array[i], Session, owner);
+				var element = elementType.Assemble(array[i], Session, owner);
 				if (element != null)
 				{
 					WrappedSet.Add((T) element);

src/NHibernate/Collection/PersistentArrayHolder.cs

@@ -196,9 +196,15 @@ public override void InitializeFromCache(ICollectionPersister persister, object
 
 			array = System.Array.CreateInstance(persister.ElementClass, cached.Length);
 
+			var elementType = persister.ElementType;
 			for (int i = 0; i < cached.Length; i++)
 			{
-				array.SetValue(persister.ElementType.Assemble(cached[i], Session, owner), i);
+				elementType.BeforeAssemble(cached[i], Session);
+			}
+
+			for (int i = 0; i < cached.Length; i++)
+			{
+				array.SetValue(elementType.Assemble(cached[i], Session, owner), i);
 			}
 		}