Fix GetQueryCache building two different caches for same region.

Author: fredericDelaporte

src/NHibernate.Test/Async/CacheTest/GetQueryCacheFixture.cs

@@ -37,6 +37,7 @@ public async Task RetrievedQueryCacheMatchesGloballyStoredOneAsync()
 		{
 			var region = "RetrievedQueryCacheMatchesGloballyStoredOne";
 			LockedCache.Semaphore = new SemaphoreSlim(0);
+			LockedCache.CreationCount = 0;
 			try
 			{
 				var failures = new ConcurrentBag<Exception>();
@@ -89,44 +90,7 @@ public async Task RetrievedQueryCacheMatchesGloballyStoredOneAsync()
 			var queryCache = Sfi.GetQueryCache(region).Cache;
 			var globalCache = Sfi.GetSecondLevelCacheRegion(region);
 			Assert.That(globalCache, Is.SameAs(queryCache));
+			Assert.That(LockedCache.CreationCount, Is.EqualTo(1));
 		}
 	}
-
-	public partial class LockedCache : ICache
-	{
-
-		#region Void implementation
-
-		public Task<object> GetAsync(object key, CancellationToken cancellationToken)
-		{
-			return Task.FromResult<object>(null);
-		}
-
-		public Task PutAsync(object key, object value, CancellationToken cancellationToken)
-		{
-			return Task.CompletedTask;
-		}
-
-		public Task RemoveAsync(object key, CancellationToken cancellationToken)
-		{
-			return Task.CompletedTask;
-		}
-
-		public Task ClearAsync(CancellationToken cancellationToken)
-		{
-			return Task.CompletedTask;
-		}
-
-		public Task LockAsync(object key, CancellationToken cancellationToken)
-		{
-			return Task.CompletedTask;
-		}
-
-		public Task UnlockAsync(object key, CancellationToken cancellationToken)
-		{
-			return Task.CompletedTask;
-		}
-
-		#endregion
-	}
 }

src/NHibernate.Test/Async/SecondLevelCacheTest/InvalidationTests.cs

@@ -14,7 +14,6 @@
 using System.Reflection;
 using NHibernate.Cache;
 using NHibernate.Cfg;
-using NHibernate.Engine;
 using NHibernate.Impl;
 using NHibernate.Test.SecondLevelCacheTests;
 using NSubstitute;

src/NHibernate.Test/CacheTest/GetQueryCacheFixture.cs

@@ -26,6 +26,7 @@ public void RetrievedQueryCacheMatchesGloballyStoredOne()
 		{
 			var region = "RetrievedQueryCacheMatchesGloballyStoredOne";
 			LockedCache.Semaphore = new SemaphoreSlim(0);
+			LockedCache.CreationCount = 0;
 			try
 			{
 				var failures = new ConcurrentBag<Exception>();
@@ -78,60 +79,27 @@ public void RetrievedQueryCacheMatchesGloballyStoredOne()
 			var queryCache = Sfi.GetQueryCache(region).Cache;
 			var globalCache = Sfi.GetSecondLevelCacheRegion(region);
 			Assert.That(globalCache, Is.SameAs(queryCache));
+			Assert.That(LockedCache.CreationCount, Is.EqualTo(1));
 		}
 	}
 
-	public partial class LockedCache : ICache
+	public class LockedCache : HashtableCache
 	{
 		public static SemaphoreSlim Semaphore { get; set; }
 
-		public LockedCache(string regionName)
-		{
-			RegionName = regionName;
-			Semaphore?.Wait();
-		}
-
-		#region Void implementation
-
-		public object Get(object key)
-		{
-			return null;
-		}
-
-		public void Put(object key, object value)
-		{
-		}
-
-		public void Remove(object key)
-		{
-		}
-
-		public void Clear()
-		{
-		}
-
-		public void Destroy()
-		{
-		}
-
-		public void Lock(object key)
-		{
-		}
+		private static int _creationCount;
 
-		public void Unlock(object key)
+		public static int CreationCount
 		{
+			get => _creationCount;
+			set => _creationCount = value;
 		}
 
-		public long NextTimestamp()
+		public LockedCache(string regionName) : base(regionName)
 		{
-			return Timestamper.Next();
+			Semaphore?.Wait();
+			Interlocked.Increment(ref _creationCount);
 		}
-
-		public int Timeout => Timestamper.OneMs * 60000;
-
-		public string RegionName { get; }
-
-		#endregion
 	}
 
 	public class LockedCacheProvider : ICacheProvider

src/NHibernate/Async/Impl/SessionFactoryImpl.cs

@@ -86,9 +86,9 @@ public sealed partial class SessionFactoryImpl : ISessionFactoryImplementor, IOb
 			{
 				queryCache.Destroy();
 
-				foreach (IQueryCache cache in queryCaches.Values)
+				foreach (var cache in queryCaches.Values)
 				{
-					cache.Destroy();
+					cache.Value.Destroy();
 				}
 
 				updateTimestampsCache.Destroy();
@@ -296,10 +296,9 @@ public sealed partial class SessionFactoryImpl : ISessionFactoryImplementor, IOb
 				{
 					if (settings.IsQueryCacheEnabled)
 					{
-						IQueryCache currentQueryCache;
-						if (queryCaches.TryGetValue(cacheRegion, out currentQueryCache))
+						if (queryCaches.TryGetValue(cacheRegion, out var currentQueryCache))
 						{
-							return currentQueryCache.ClearAsync(cancellationToken);
+							return currentQueryCache.Value.ClearAsync(cancellationToken);
 						}
 					}
 				}

src/NHibernate/Impl/SessionFactoryImpl.cs

@@ -148,7 +148,7 @@ public void HandleEntityNotFound(string entityName, object id)
 		private readonly IQueryCache queryCache;
 
 		[NonSerialized]
-		private readonly ConcurrentDictionary<string, IQueryCache> queryCaches;
+		private readonly ConcurrentDictionary<string, Lazy<IQueryCache>> queryCaches;
 		[NonSerialized]
 		private readonly SchemaExport schemaExport;
 		[NonSerialized]
@@ -379,7 +379,7 @@ public SessionFactoryImpl(Configuration cfg, IMapping mapping, Settings settings
 			{
 				updateTimestampsCache = new UpdateTimestampsCache(settings, properties);
 				queryCache = settings.QueryCacheFactory.GetQueryCache(null, updateTimestampsCache, settings, properties);
-				queryCaches = new ConcurrentDictionary<string, IQueryCache>();
+				queryCaches = new ConcurrentDictionary<string, Lazy<IQueryCache>>();
 			}
 			else
 			{
@@ -845,9 +845,9 @@ public void Close()
 			{
 				queryCache.Destroy();
 
-				foreach (IQueryCache cache in queryCaches.Values)
+				foreach (var cache in queryCaches.Values)
 				{
-					cache.Destroy();
+					cache.Value.Destroy();
 				}
 
 				updateTimestampsCache.Destroy();
@@ -1027,21 +1027,18 @@ public IQueryCache GetQueryCache(string cacheRegion)
 				return null;
 			}
 
-			var wasAdded = false;
 			// The factory may be run concurrently by threads trying to get the same region.
-			// But the GetOrAdd will yield the same cache for all threads, so in case of add, use
-			// it to update allCacheRegions
-			var cache = queryCaches.GetOrAdd(
+			// But the GetOrAdd will yield the same lazy for all threads, so only one will
+			// initialize. https://stackoverflow.com/a/31637510/1178314
+			return queryCaches.GetOrAdd(
 				cacheRegion,
-				cr =>
-				{
-					var currentQueryCache = settings.QueryCacheFactory.GetQueryCache(cacheRegion, updateTimestampsCache, settings, properties);
-					wasAdded = true;
-					return currentQueryCache;
-				});
-			if (wasAdded)
-				allCacheRegions[cache.RegionName] = cache.Cache;
-			return cache;
+				cr => new Lazy<IQueryCache>(
+					() =>
+					{
+						var currentQueryCache = settings.QueryCacheFactory.GetQueryCache(cr, updateTimestampsCache, settings, properties);
+						allCacheRegions[currentQueryCache.RegionName] = currentQueryCache.Cache;
+						return currentQueryCache;
+					})).Value;
 		}
 
 		public void EvictQueries()
@@ -1067,10 +1064,9 @@ public void EvictQueries(string cacheRegion)
 			{
 				if (settings.IsQueryCacheEnabled)
 				{
-					IQueryCache currentQueryCache;
-					if (queryCaches.TryGetValue(cacheRegion, out currentQueryCache))
+					if (queryCaches.TryGetValue(cacheRegion, out var currentQueryCache))
 					{
-						currentQueryCache.Clear();
+						currentQueryCache.Value.Clear();
 					}
 				}
 			}

src/NHibernate/Util/StringHelper.cs

@@ -159,7 +159,7 @@ public static string ReplaceOnce(string template, string placeholder, string rep
 		}
 
 		/// <summary>
-		/// Just a façade for calling string.Split()
+		/// Just a facade for calling string.Split()
 		/// We don't use our StringTokenizer because string.Split() is
 		/// more efficient (but it only works when we don't want to retrieve the delimiters)
 		/// </summary>