Avoid recursive calls in BatchFetchQueue

Author: hazzik

src/NHibernate/Async/Engine/BatchFetchQueue.cs

@@ -266,7 +266,7 @@ internal async Task<object[]> GetEntityBatchAsync(IEntityPersister persister, ob
 			foreach (var key in set)
 			{
 				cancellationToken.ThrowIfCancellationRequested();
-				if (await (ProcessKeyAsync(key)).ConfigureAwait(false))
+				if (ProcessKey(key) ?? await (CheckCacheAndProcessResultAsync()).ConfigureAwait(false))
 				{
 					return ids;
 				}
@@ -299,7 +299,7 @@ async Task<bool> CheckCacheAndProcessResultAsync()
 				{
 					for (var j = 0; j < entityKeys.Count; j++)
 					{
-						if (await (ProcessKeyAsync(entityKeys[indexes[j]].Key)).ConfigureAwait(false))
+						if (ProcessKey(entityKeys[indexes[j]].Key) == true)
 						{
 							return true;
 						}
@@ -310,7 +310,7 @@ async Task<bool> CheckCacheAndProcessResultAsync()
 					var results = await (AreCachedAsync(entityKeys, indexes, persister, batchableCache, checkCache, cancellationToken)).ConfigureAwait(false);
 					for (var j = 0; j < results.Length; j++)
 					{
-						if (!results[j] && await (ProcessKeyAsync(entityKeys[indexes[j]].Key, true)).ConfigureAwait(false))
+						if (!results[j] && ProcessKey(entityKeys[indexes[j]].Key, true) == true)
 						{
 							return true;
 						}
@@ -324,62 +324,59 @@ async Task<bool> CheckCacheAndProcessResultAsync()
 				return false;
 			}
 
-			Task<bool> ProcessKeyAsync(EntityKey key, bool ignoreCache = false)
+			bool? ProcessKey(EntityKey key, bool ignoreCache = false)
 			{
-				try
+				//TODO: this needn't exclude subclasses...
+				if (checkForEnd && (index == set.Count || index >= idIndex.Value + batchSize))
 				{
-					//TODO: this needn't exclude subclasses...
-					if (checkForEnd && (index == set.Count || index >= idIndex.Value + batchSize))
-					{
-						return Task.FromResult<bool>(true);
-					}
-					if (persister.IdentifierType.IsEqual(id, key.Identifier))
-					{
-						idIndex = index;
-					}
-					else if (!checkCache || batchableCache == null)
-					{
-						if (index < set.Count && (!idIndex.HasValue || index < idIndex.Value))
-						{
-							entityKeys.Add(new KeyValuePair<EntityKey, int>(key, index));
-							return Task.FromResult<bool>(false);
-						}
+					return true;
+				}
 
-						// No need to check "!checkCache || !IsCached(key, persister)": "batchableCache == null"
-						// already means there is no cache, so IsCached can only yield false. (This method is now
-						// removed.)
-						ids[i++] = key.Identifier;
-					}
-					else if (ignoreCache)
-					{
-						ids[i++] = key.Identifier;
-					}
-					else
+				if (persister.IdentifierType.IsEqual(id, key.Identifier))
+				{
+					idIndex = index;
+				}
+				else if (!checkCache || batchableCache == null)
+				{
+					if (index < set.Count && (!idIndex.HasValue || index < idIndex.Value))
 					{
 						entityKeys.Add(new KeyValuePair<EntityKey, int>(key, index));
-						// Check the cache only when we have collected as many keys as are needed to fill the batch,
-						// that are after the demanded key.
-						if (!idIndex.HasValue || index < idIndex.Value + batchSize)
-						{
-							return Task.FromResult<bool>(false);
-						}
-						return CheckCacheAndProcessResultAsync();
+						return false;
 					}
-					if (i == batchSize)
+
+					// No need to check "!checkCache || !IsCached(key, persister)": "batchableCache == null"
+					// already means there is no cache, so IsCached can only yield false. (This method is now
+					// removed.)
+					ids[i++] = key.Identifier;
+				}
+				else if (ignoreCache)
+				{
+					ids[i++] = key.Identifier;
+				}
+				else
+				{
+					entityKeys.Add(new KeyValuePair<EntityKey, int>(key, index));
+					// Check the cache only when we have collected as many keys as are needed to fill the batch,
+					// that are after the demanded key.
+					if (!idIndex.HasValue || index < idIndex.Value + batchSize)
 					{
-						i = 1; // End of array, start filling again from start
-						if (index == set.Count || idIndex.HasValue)
-						{
-							checkForEnd = true;
-							return Task.FromResult<bool>(index == set.Count || index >= idIndex.Value + batchSize);
-						}
+						return false;
 					}
-					return Task.FromResult<bool>(false);
+
+					return null;
 				}
-				catch (Exception ex)
+
+				if (i == batchSize)
 				{
-					return Task.FromException<bool>(ex);
+					i = 1; // End of array, start filling again from start
+					if (index == set.Count || idIndex.HasValue)
+					{
+						checkForEnd = true;
+						return index == set.Count || index >= idIndex.Value + batchSize;
+					}
 				}
+
+				return false;
 			}
 		}
 

src/NHibernate/Engine/BatchFetchQueue.cs

@@ -427,7 +427,7 @@ internal object[] GetEntityBatch(IEntityPersister persister, object id, int batc
 
 			foreach (var key in set)
 			{
-				if (ProcessKey(key))
+				if (ProcessKey(key) ?? CheckCacheAndProcessResult())
 				{
 					return ids;
 				}
@@ -459,7 +459,7 @@ bool CheckCacheAndProcessResult()
 				{
 					for (var j = 0; j < entityKeys.Count; j++)
 					{
-						if (ProcessKey(entityKeys[indexes[j]].Key))
+						if (ProcessKey(entityKeys[indexes[j]].Key) == true)
 						{
 							return true;
 						}
@@ -470,7 +470,7 @@ bool CheckCacheAndProcessResult()
 					var results = AreCached(entityKeys, indexes, persister, batchableCache, checkCache);
 					for (var j = 0; j < results.Length; j++)
 					{
-						if (!results[j] && ProcessKey(entityKeys[indexes[j]].Key, true))
+						if (!results[j] && ProcessKey(entityKeys[indexes[j]].Key, true) == true)
 						{
 							return true;
 						}
@@ -484,13 +484,14 @@ bool CheckCacheAndProcessResult()
 				return false;
 			}
 
-			bool ProcessKey(EntityKey key, bool ignoreCache = false)
+			bool? ProcessKey(EntityKey key, bool ignoreCache = false)
 			{
 				//TODO: this needn't exclude subclasses...
 				if (checkForEnd && (index == set.Count || index >= idIndex.Value + batchSize))
 				{
 					return true;
 				}
+
 				if (persister.IdentifierType.IsEqual(id, key.Identifier))
 				{
 					idIndex = index;
@@ -521,8 +522,10 @@ bool ProcessKey(EntityKey key, bool ignoreCache = false)
 					{
 						return false;
 					}
-					return CheckCacheAndProcessResult();
+
+					return null;
 				}
+
 				if (i == batchSize)
 				{
 					i = 1; // End of array, start filling again from start
@@ -532,6 +535,7 @@ bool ProcessKey(EntityKey key, bool ignoreCache = false)
 						return index == set.Count || index >= idIndex.Value + batchSize;
 					}
 				}
+
 				return false;
 			}
 		}