fixup! Replace ICache interface by a CacheBase class

Add missing cleanup

Author: fredericDelaporte

src/NHibernate/Async/Engine/BatchFetchQueue.cs

@@ -133,7 +133,7 @@ async Task<bool> CheckCacheAndProcessResultAsync()
 				return false;
 			}
 
-			async Task<bool> ProcessKeyAsync(KeyValuePair<CollectionEntry, IPersistentCollection> me, bool ignoreCache = false)
+			Task<bool> ProcessKeyAsync(KeyValuePair<CollectionEntry, IPersistentCollection> me, bool ignoreCache = false)
 			{
 				var ce = me.Key;
 				var collection = me.Value;
@@ -144,18 +144,18 @@ async Task<bool> ProcessKeyAsync(KeyValuePair<CollectionEntry, IPersistentCollec
 					// and CollectionEntry.AfterAction())
 					// though we clear the queue on flush, it seems like a good idea to guard
 					// against potentially null LoadedKey:s
-					return false;
+					return Task.FromResult<bool>(false);
 				}
 
 				if (collection.WasInitialized)
 				{
 					log.Warn("Encountered initialized collection in BatchFetchQueue, this should not happen.");
-					return false;
+					return Task.FromResult<bool>(false);
 				}
 
 				if (checkForEnd && (index >= keyIndex.Value + batchSize || index == map.Count))
 				{
-					return true;
+					return Task.FromResult<bool>(true);
 				}
 				if (collectionPersister.KeyType.IsEqual(id, ce.LoadedKey, collectionPersister.Factory))
 				{
@@ -170,17 +170,17 @@ async Task<bool> ProcessKeyAsync(KeyValuePair<CollectionEntry, IPersistentCollec
 					if (!keyIndex.HasValue || index < keyIndex.Value)
 					{
 						collectionKeys.Add(new KeyValuePair<KeyValuePair<CollectionEntry, IPersistentCollection>, int>(me, index));
-						return false;
+						return Task.FromResult<bool>(false);
 					}
 
-					if (!checkCache || !await (IsCachedAsync(ce.LoadedKey, collectionPersister, cancellationToken)).ConfigureAwait(false))
+					// No need to check "!checkCache || !IsCached(ce.LoadedKey, collectionPersister)":
+					// "batchableCache == null" already means there is no cache, so IsCached can only yield false.
+					// (This method is now removed.)
+					if (collectionEntries != null)
 					{
-						if (collectionEntries != null)
-						{
-							collectionEntries[i] = ce;
-						}
-						keys[i++] = ce.LoadedKey;
+						collectionEntries[i] = ce;
 					}
+					keys[i++] = ce.LoadedKey;
 				}
 				else if (ignoreCache)
 				{
@@ -197,20 +197,20 @@ async Task<bool> ProcessKeyAsync(KeyValuePair<CollectionEntry, IPersistentCollec
 					// that are after the demanded key.
 					if (!keyIndex.HasValue || index < keyIndex.Value + batchSize)
 					{
-						return false;
+						return Task.FromResult<bool>(false);
 					}
-					return await (CheckCacheAndProcessResultAsync()).ConfigureAwait(false);
+					return CheckCacheAndProcessResultAsync();
 				}
 				if (i == batchSize)
 				{
 					i = 1; // End of array, start filling again from start
 					if (keyIndex.HasValue)
 					{
 						checkForEnd = true;
-						return index >= keyIndex.Value + batchSize || index == map.Count;
+						return Task.FromResult<bool>(index >= keyIndex.Value + batchSize || index == map.Count);
 					}
 				}
-				return false;
+				return Task.FromResult<bool>(false);
 			}
 		}
 
@@ -378,17 +378,6 @@ Task<bool> ProcessKeyAsync(EntityKey key, bool ignoreCache = false)
 			}
 		}
 
-		private async Task<bool> IsCachedAsync(object collectionKey, ICollectionPersister persister, CancellationToken cancellationToken)
-		{
-			cancellationToken.ThrowIfCancellationRequested();
-			if (persister.HasCache && context.Session.CacheMode.HasFlag(CacheMode.Get))
-			{
-				CacheKey cacheKey = context.Session.GenerateCacheKey(collectionKey, persister.KeyType, persister.Role);
-				return await (persister.Cache.Cache.GetAsync(cacheKey, cancellationToken)).ConfigureAwait(false) != null;
-			}
-			return false;
-		}
-
 		/// <summary>
 		/// Checks whether the given entity key indexes are cached.
 		/// </summary>

src/NHibernate/Engine/BatchFetchQueue.cs

@@ -342,14 +342,14 @@ bool ProcessKey(KeyValuePair<CollectionEntry, IPersistentCollection> me, bool ig
 						return false;
 					}
 
-					if (!checkCache || !IsCached(ce.LoadedKey, collectionPersister))
+					// No need to check "!checkCache || !IsCached(ce.LoadedKey, collectionPersister)":
+					// "batchableCache == null" already means there is no cache, so IsCached can only yield false.
+					// (This method is now removed.)
+					if (collectionEntries != null)
 					{
-						if (collectionEntries != null)
-						{
-							collectionEntries[i] = ce;
-						}
-						keys[i++] = ce.LoadedKey;
+						collectionEntries[i] = ce;
 					}
+					keys[i++] = ce.LoadedKey;
 				}
 				else if (ignoreCache)
 				{
@@ -538,16 +538,6 @@ bool ProcessKey(EntityKey key, bool ignoreCache = false)
 			}
 		}
 
-		private bool IsCached(object collectionKey, ICollectionPersister persister)
-		{
-			if (persister.HasCache && context.Session.CacheMode.HasFlag(CacheMode.Get))
-			{
-				CacheKey cacheKey = context.Session.GenerateCacheKey(collectionKey, persister.KeyType, persister.Role);
-				return persister.Cache.Cache.Get(cacheKey) != null;
-			}
-			return false;
-		}
-
 		/// <summary>
 		/// Checks whether the given entity key indexes are cached.
 		/// </summary>