Remove delegate based logic

Author: hazzik

src/NHibernate/Cache/CacheFactory.cs

@@ -39,36 +39,28 @@ public static ICacheConcurrencyStrategy CreateCache(
 			Settings settings,
 			IDictionary<string, string> properties)
 		{
-			var cache = CreateCache(
-				usage, name, settings,
-				r => settings.CacheProvider.BuildCache(r, properties).AsCacheBase());
+			if (usage == null || !settings.IsSecondLevelCacheEnabled) return null;
 
-			if (cache != null && mutable && usage == ReadOnly)
-				log.Warn("read-only cache configured for mutable: {0}", name);
+			var cache = BuildCacheBase(name, settings, properties);
+
+			var ccs = CreateCache(usage,cache);
 
-			return cache;
+			if (mutable && usage == ReadOnly)
+				log.Warn("read-only cache configured for mutable: {0}", name);
+			
+			return ccs;
 		}
 
 		/// <summary>
 		/// Creates an <see cref="ICacheConcurrencyStrategy"/> from the parameters.
 		/// </summary>
 		/// <param name="usage">The name of the strategy that <see cref="ICacheProvider"/> should use for the class.</param>
-		/// <param name="name">The name of the cache region the strategy is being created for.</param>
-		/// <param name="settings">Used to retrieve the global cache region prefix.</param>
-		/// <param name="regionAndUsageCacheGetter">The delegate for obtaining the <see cref="ICache" /> to use for the region.</param>
+		/// <param name="cache">The <see cref="CacheBase"/> used for this strategy.</param>
 		/// <returns>An <see cref="ICacheConcurrencyStrategy"/> to use for this object in the <see cref="ICache"/>.</returns>
-		public static ICacheConcurrencyStrategy CreateCache(
-			string usage,
-			string name,
-			Settings settings,
-			Func<string, CacheBase> regionAndUsageCacheGetter)
+		public static ICacheConcurrencyStrategy CreateCache(string usage, CacheBase cache)
 		{
-			if (usage == null || !settings.IsSecondLevelCacheEnabled) return null; //no cache
-
 			if (log.IsDebugEnabled())
-			{
-				log.Debug("cache for: {0} usage strategy: {1}", name, usage);
-			}
+				log.Debug("cache for: {0} usage strategy: {1}", cache.RegionName, usage);
 
 			ICacheConcurrencyStrategy ccs;
 			switch (usage)
@@ -90,16 +82,21 @@ public static ICacheConcurrencyStrategy CreateCache(
 						"cache usage attribute should be read-write, read-only or nonstrict-read-write");
 			}
 
+			ccs.Cache = cache;
+
+			return ccs;
+		}
+
+		internal static CacheBase BuildCacheBase(string name, Settings settings, IDictionary<string, string> properties)
+		{
 			try
 			{
-				ccs.Cache = regionAndUsageCacheGetter(name);
+				return settings.CacheProvider.BuildCache(name, properties).AsCacheBase();
 			}
 			catch (CacheException e)
 			{
 				throw new HibernateException("Could not instantiate cache implementation", e);
 			}
-
-			return ccs;
 		}
 	}
 }

src/NHibernate/Cache/StandardQueryCache.cs

@@ -31,20 +31,13 @@ public StandardQueryCache(
 			string regionName)
 			: this(
 				updateTimestampsCache,
-				settings.CacheProvider.BuildCache(
-					(!string.IsNullOrEmpty(settings.CacheRegionPrefix) ? settings.CacheRegionPrefix + '.' : "") +
-					(regionName ?? typeof (StandardQueryCache).FullName),
+				CacheFactory.BuildCacheBase(
+					settings.GetFullCacheRegionName(regionName ?? typeof(StandardQueryCache).FullName),
+					settings,
 					props))
 		{
 		}
 
-		// Since v5.2
-		[Obsolete]
-		private StandardQueryCache(UpdateTimestampsCache updateTimestampsCache, ICache cache)
-			: this(updateTimestampsCache, cache.AsCacheBase())
-		{
-		}
-
 		/// <summary>
 		/// Build a query cache.
 		/// </summary>
@@ -60,7 +53,6 @@ public StandardQueryCache(
 			_regionName = regionCache.RegionName;
 			Log.Info("starting query cache at region: {0}", _regionName);
 
-			Cache = regionCache;
 			_cache = regionCache;
 			_updateTimestampsCache = updateTimestampsCache;
 		}
@@ -69,7 +61,7 @@ public StandardQueryCache(
 
 		// 6.0 TODO: type as CacheBase instead
 #pragma warning disable 618
-		public ICache Cache { get; }
+		public ICache Cache => _cache;
 #pragma warning restore 618
 
 		public string RegionName

src/NHibernate/Cache/UpdateTimestampsCache.cs

@@ -29,15 +29,10 @@ public virtual void Clear()
 		[Obsolete("Please use overload with an CacheBase parameter.")]
 		public UpdateTimestampsCache(Settings settings, IDictionary<string, string> props)
 			: this(
-				settings.CacheProvider.BuildCache(
-					(settings.CacheRegionPrefix == null ? "" : settings.CacheRegionPrefix + '.') +
-					typeof(UpdateTimestampsCache).Name,
-					props)) {}
-
-		// Since v5.2
-		[Obsolete]
-		private UpdateTimestampsCache(ICache cache)
-			: this(cache.AsCacheBase())
+				CacheFactory.BuildCacheBase(
+					settings.GetFullCacheRegionName(nameof(UpdateTimestampsCache)),
+					settings,
+					props))
 		{
 		}
 

src/NHibernate/Cfg/Settings.cs

@@ -137,5 +137,13 @@ public Settings()
 		public IQueryModelRewriterFactory QueryModelRewriterFactory { get; internal set; }
 
 		#endregion
+
+		internal string GetFullCacheRegionName(string name)
+		{
+			var prefix = CacheRegionPrefix;
+			if (!string.IsNullOrEmpty(prefix))
+				return prefix + '.' + name;
+			return name;
+		}
 	}
 }

src/NHibernate/Impl/SessionFactoryImpl.cs

@@ -433,18 +433,15 @@ private ICacheConcurrencyStrategy GetCacheConcurrencyStrategy(
 			Dictionary<Tuple<string, string>, ICacheConcurrencyStrategy> caches)
 		{
 			var cacheKey = new Tuple<string, string>(cacheRegion, strategy);
-			if (!caches.TryGetValue(cacheKey, out var cache))
-			{
-				cache = CacheFactory.CreateCache(
-					strategy,
-					cacheRegion,
-					settings,
-					BuildCache);
-				if (cache != null)
-					caches.Add(cacheKey, cache);
-			}
+			if (strategy == null || !settings.IsSecondLevelCacheEnabled)
+				return null;
+
+			if (caches.TryGetValue(cacheKey, out var cache)) 
+				return cache;
 
-			if (cache != null && isMutable && strategy == CacheFactory.ReadOnly)
+			cache = CacheFactory.CreateCache(strategy, BuildCache(cacheRegion));
+			caches.Add(cacheKey, cache);
+			if (isMutable && strategy == CacheFactory.ReadOnly)
 				log.Warn("read-only cache configured for mutable: {0}", name);
 
 			return cache;
@@ -1093,11 +1090,11 @@ private CacheBase BuildCache(string cacheRegion)
 			// concurrent creation call for the same region, so this will not happen.
 			// Otherwise the dictionary will have to be changed for using a lazy, see
 			// https://stackoverflow.com/a/31637510/1178314
-			var prefix = settings.CacheRegionPrefix;
-			if (!string.IsNullOrEmpty(prefix))
-				cacheRegion = prefix + '.' + cacheRegion;
+			cacheRegion = settings.GetFullCacheRegionName(cacheRegion);
 
-			return _allCacheRegions.GetOrAdd(cacheRegion, cr => settings.CacheProvider.BuildCache(cr, properties).AsCacheBase());
+			return _allCacheRegions.GetOrAdd(
+				cacheRegion,
+				cr => CacheFactory.BuildCacheBase(cr, settings, properties));
 		}
 
 		/// <summary> Statistics SPI</summary>