Added IBatchableCacheConcurrencyStrategy and replaced XXXMultiple with XXXMany.

Author: maca88

src/NHibernate.Test/Async/CacheTest/Caches/BatchableCache.cs

@@ -22,7 +22,7 @@ namespace NHibernate.Test.CacheTest.Caches
 	public partial class BatchableCache : ICache, IBatchableReadWriteCache
 	{
 
-		public Task PutMultipleAsync(object[] keys, object[] values, CancellationToken cancellationToken)
+		public Task PutManyAsync(object[] keys, object[] values, CancellationToken cancellationToken)
 		{
 			try
 			{
@@ -39,7 +39,7 @@ public Task PutMultipleAsync(object[] keys, object[] values, CancellationToken c
 			}
 		}
 
-		public Task LockMultipleAsync(object[] keys, CancellationToken cancellationToken)
+		public Task LockManyAsync(object[] keys, CancellationToken cancellationToken)
 		{
 			try
 			{
@@ -52,7 +52,7 @@ public Task LockMultipleAsync(object[] keys, CancellationToken cancellationToken
 			}
 		}
 
-		public Task UnlockMultipleAsync(object[] keys, CancellationToken cancellationToken)
+		public Task UnlockManyAsync(object[] keys, CancellationToken cancellationToken)
 		{
 			try
 			{
@@ -81,7 +81,7 @@ public Task<object> GetAsync(object key, CancellationToken cancellationToken)
 			}
 		}
 
-		public Task<object[]> GetMultipleAsync(object[] keys, CancellationToken cancellationToken)
+		public Task<object[]> GetManyAsync(object[] keys, CancellationToken cancellationToken)
 		{
 			try
 			{

src/NHibernate.Test/CacheTest/Caches/BatchableCache.cs

@@ -12,7 +12,6 @@ namespace NHibernate.Test.CacheTest.Caches
 	public partial class BatchableCache : ICache, IBatchableReadWriteCache
 	{
 		private readonly IDictionary _hashtable = new Hashtable();
-		private readonly string _regionName;
 
 		public List<object[]> GetMultipleCalls { get; } = new List<object[]>();
 
@@ -26,7 +25,7 @@ public partial class BatchableCache : ICache, IBatchableReadWriteCache
 
 		public List<object> PutCalls { get; } = new List<object>();
 
-		public void PutMultiple(object[] keys, object[] values)
+		public void PutMany(object[] keys, object[] values)
 		{
 			PutMultipleCalls.Add(keys);
 			for (int i = 0; i < keys.Length; i++)
@@ -35,12 +34,12 @@ public void PutMultiple(object[] keys, object[] values)
 			}
 		}
 
-		public void LockMultiple(object[] keys)
+		public void LockMany(object[] keys)
 		{
 			LockMultipleCalls.Add(keys);
 		}
 
-		public void UnlockMultiple(object[] keys)
+		public void UnlockMany(object[] keys)
 		{
 			UnlockMultipleCalls.Add(keys);
 		}
@@ -49,7 +48,7 @@ public void UnlockMultiple(object[] keys)
 
 		public BatchableCache(string regionName)
 		{
-			_regionName = regionName;
+			RegionName = regionName;
 		}
 
 		/// <summary></summary>
@@ -59,7 +58,7 @@ public object Get(object key)
 			return _hashtable[key];
 		}
 
-		public object[] GetMultiple(object[] keys)
+		public object[] GetMany(object[] keys)
 		{
 			GetMultipleCalls.Add(keys);
 			var result = new object[keys.Length];
@@ -123,18 +122,9 @@ public long NextTimestamp()
 		}
 
 		/// <summary></summary>
-		public int Timeout
-		{
-			get
-			{
-				return Timestamper.OneMs * 60000; // ie. 60 seconds
-			}
-		}
+		public int Timeout => Timestamper.OneMs * 60000;
 
-		public string RegionName
-		{
-			get { return _regionName; }
-		}
+		public string RegionName { get; }
 
 		#endregion
 	}

src/NHibernate/Async/Cache/CachePutBatch.cs

@@ -44,7 +44,7 @@ protected override async Task ExecuteAsync(CachePutData[] data, CancellationToke
 
 			var factory = Session.Factory;
 			var cacheStrategy = CacheConcurrencyStrategy;
-			var puts = await (cacheStrategy.PutMultipleAsync(keys, values, Session.Timestamp, versions, versionComparers, minimalPuts, cancellationToken)).ConfigureAwait(false);
+			var puts = await (cacheStrategy.PutManyAsync(keys, values, Session.Timestamp, versions, versionComparers, minimalPuts, cancellationToken)).ConfigureAwait(false);
 
 			if (factory.Statistics.IsStatisticsEnabled && puts.Any(o => o))
 			{

src/NHibernate/Async/Cache/IBatchableCacheConcurrencyStrategy.cs

@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System;
+using System.Collections;
+using System.Text;
+using NHibernate.Cache.Entry;
+
+namespace NHibernate.Cache
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+	public partial interface IBatchableCacheConcurrencyStrategy : ICacheConcurrencyStrategy
+	{
+		/// <summary>
+		/// Attempt to retrieve multiple objects from the Cache
+		/// </summary>
+		/// <param name="keys">The keys (id) of the objects to get out of the Cache.</param>
+		/// <param name="timestamp">A timestamp prior to the transaction start time</param>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		/// <returns>An array of cached objects or <see langword="null" /></returns>
+		/// <exception cref="CacheException"></exception>
+		Task<object[]> GetManyAsync(CacheKey[] keys, long timestamp, CancellationToken cancellationToken);
+
+		/// <summary>
+		/// Attempt to cache objects, after loading them from the database.
+		/// </summary>
+		/// <param name="keys">The keys (id) of the objects to put in the Cache.</param>
+		/// <param name="values">The objects to put in the cache.</param>
+		/// <param name="timestamp">A timestamp prior to the transaction start time.</param>
+		/// <param name="versions">The version numbers of the objects we are putting.</param>
+		/// <param name="versionComparers">The comparers to be used to compare version numbers</param>
+		/// <param name="minimalPuts">Indicates that the cache should avoid a put if the item is already cached.</param>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		/// <returns><see langword="true" /> if the objects were successfully cached.</returns>
+		/// <exception cref="CacheException"></exception>
+		Task<bool[]> PutManyAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,
+								  bool[] minimalPuts, CancellationToken cancellationToken);
+	}
+}

src/NHibernate/Async/Cache/IBatchableReadCache.cs

@@ -24,6 +24,6 @@ public partial interface IBatchableReadCache
 		/// <param name="keys">The keys to be retrieved from the cache.</param>
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
 		/// <returns></returns>
-		Task<object[]> GetMultipleAsync(object[] keys, CancellationToken cancellationToken);
+		Task<object[]> GetManyAsync(object[] keys, CancellationToken cancellationToken);
 	}
 }

src/NHibernate/Async/Cache/IBatchableWriteCache.cs

@@ -24,20 +24,20 @@ public partial interface IBatchableReadWriteCache : IBatchableReadCache
 		/// <param name="keys">The keys to cache.</param>
 		/// <param name="values">The objects to cache.</param>
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
-		Task PutMultipleAsync(object[] keys, object[] values, CancellationToken cancellationToken);
+		Task PutManyAsync(object[] keys, object[] values, CancellationToken cancellationToken);
 
 		/// <summary>
 		/// Lock the objects from being changed by another thread.
 		/// </summary>
 		/// <param name="keys">The keys to lock.</param>
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
-		Task LockMultipleAsync(object[] keys, CancellationToken cancellationToken);
+		Task LockManyAsync(object[] keys, CancellationToken cancellationToken);
 
 		/// <summary>
 		/// Unlock the objects that were previously locked.
 		/// </summary>
 		/// <param name="keys">The keys to unlock.</param>
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
-		Task UnlockMultipleAsync(object[] keys, CancellationToken cancellationToken);
+		Task UnlockManyAsync(object[] keys, CancellationToken cancellationToken);
 	}
 }

src/NHibernate/Async/Cache/ICacheConcurrencyStrategy.cs

@@ -130,31 +130,21 @@ internal static partial class CacheConcurrencyStrategyExtensions
 		/// </summary>
 		/// <param name="cache">The cache concurrency strategy.</param>
 		/// <param name="keys">The keys (id) of the objects to get out of the Cache.</param>
-		/// <param name="txTimestamp">A timestamp prior to the transaction start time</param>
+		/// <param name="timestamp">A timestamp prior to the transaction start time</param>
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
 		/// <returns>An array of cached objects or <see langword="null" /></returns>
 		/// <exception cref="CacheException"></exception>
-		//6.0 TODO: Merge into ICacheConcurrencyStrategy.
-		public static async Task<object[]> GetMultipleAsync(this ICacheConcurrencyStrategy cache, CacheKey[] keys, long txTimestamp, CancellationToken cancellationToken)
+		public static Task<object[]> GetManyAsync(this ICacheConcurrencyStrategy cache, CacheKey[] keys, long timestamp, CancellationToken cancellationToken)
 		{
-			cancellationToken.ThrowIfCancellationRequested();
-			switch (cache)
+			if (!(cache is IBatchableCacheConcurrencyStrategy batchableCache))
 			{
-				case ReadOnlyCache readOnly:
-					return await (readOnly.GetMultipleAsync(keys, txTimestamp, cancellationToken)).ConfigureAwait(false);
-				case ReadWriteCache readWrite:
-					return await (readWrite.GetMultipleAsync(keys, txTimestamp, cancellationToken)).ConfigureAwait(false);
-				case NonstrictReadWriteCache nonstrictReadWrite:
-					return await (nonstrictReadWrite.GetMultipleAsync(keys, txTimestamp, cancellationToken)).ConfigureAwait(false);
+				throw new InvalidOperationException($"Cache concurrency strategy {cache.GetType()} does not support batching");
 			}
-
-			// Fallback to Get
-			var objects = new object[keys.Length];
-			for (var i = 0; i < keys.Length; i++)
+			if (cancellationToken.IsCancellationRequested)
 			{
-				objects[i] = await (cache.GetAsync(keys[i], txTimestamp, cancellationToken)).ConfigureAwait(false);
+				return Task.FromCanceled<object[]>(cancellationToken);
 			}
-			return objects;
+			return batchableCache.GetManyAsync(keys, timestamp, cancellationToken);
 		}
 
 		/// <summary>
@@ -170,28 +160,18 @@ public static async Task<object[]> GetMultipleAsync(this ICacheConcurrencyStrate
 		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
 		/// <returns><see langword="true" /> if the objects were successfully cached.</returns>
 		/// <exception cref="CacheException"></exception>
-		//6.0 TODO: Merge into ICacheConcurrencyStrategy.
-		public static async Task<bool[]> PutMultipleAsync(this ICacheConcurrencyStrategy cache, CacheKey[] keys, object[] values, long timestamp,
+		public static Task<bool[]> PutManyAsync(this ICacheConcurrencyStrategy cache, CacheKey[] keys, object[] values, long timestamp,
 		                          object[] versions, IComparer[] versionComparers, bool[] minimalPuts, CancellationToken cancellationToken)
 		{
-			cancellationToken.ThrowIfCancellationRequested();
-			switch (cache)
+			if (!(cache is IBatchableCacheConcurrencyStrategy batchableCache))
 			{
-				case ReadOnlyCache readOnly:
-					return await (readOnly.PutMultipleAsync(keys, values, timestamp, versions, versionComparers, minimalPuts, cancellationToken)).ConfigureAwait(false);
-				case ReadWriteCache readWrite:
-					return await (readWrite.PutMultipleAsync(keys, values, timestamp, versions, versionComparers, minimalPuts, cancellationToken)).ConfigureAwait(false);
-				case NonstrictReadWriteCache nonstrictReadWrite:
-					return await (nonstrictReadWrite.PutMultipleAsync(keys, values, timestamp, versions, versionComparers, minimalPuts, cancellationToken)).ConfigureAwait(false);
+				throw new InvalidOperationException($"Cache concurrency strategy {cache.GetType()} does not support batching");
 			}
-
-			// Fallback to Put
-			var result = new bool[keys.Length];
-			for (var i = 0; i < keys.Length; i++)
+			if (cancellationToken.IsCancellationRequested)
 			{
-				result[i] = await (cache.PutAsync(keys[i], values[i], timestamp, versions[i], versionComparers[i], minimalPuts[i], cancellationToken)).ConfigureAwait(false);
+				return Task.FromCanceled<bool[]>(cancellationToken);
 			}
-			return result;
+			return batchableCache.PutManyAsync(keys, values, timestamp, versions, versionComparers, minimalPuts, cancellationToken);
 		}
 	}
 }

src/NHibernate/Async/Cache/NonstrictReadWriteCache.cs

@@ -18,7 +18,7 @@ namespace NHibernate.Cache
 {
 	using System.Threading.Tasks;
 	using System.Threading;
-	public partial class NonstrictReadWriteCache : ICacheConcurrencyStrategy
+	public partial class NonstrictReadWriteCache : IBatchableCacheConcurrencyStrategy
 	{
 
 		/// <summary>
@@ -44,7 +44,7 @@ public async Task<object> GetAsync(CacheKey key, long txTimestamp, CancellationT
 			return result;
 		}
 
-		public Task<object[]> GetMultipleAsync(CacheKey[] keys, long txTimestamp, CancellationToken cancellationToken)
+		public Task<object[]> GetManyAsync(CacheKey[] keys, long timestamp, CancellationToken cancellationToken)
 		{
 			if (_batchableReadCache == null)
 			{
@@ -54,14 +54,14 @@ public Task<object[]> GetMultipleAsync(CacheKey[] keys, long txTimestamp, Cancel
 			{
 				return Task.FromCanceled<object[]>(cancellationToken);
 			}
-			return InternalGetMultipleAsync();
-			async Task<object[]> InternalGetMultipleAsync()
+			return InternalGetManyAsync();
+			async Task<object[]> InternalGetManyAsync()
 			{
 				if (log.IsDebugEnabled())
 				{
 					log.Debug("Cache lookup: {0}", string.Join(",", keys.AsEnumerable()));
 				}
-				var results = await (_batchableReadCache.GetMultipleAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
+				var results = await (_batchableReadCache.GetManyAsync(keys.Select(o => (object) o).ToArray(), cancellationToken)).ConfigureAwait(false);
 				if (!log.IsDebugEnabled())
 				{
 					return results;
@@ -77,7 +77,7 @@ async Task<object[]> InternalGetMultipleAsync()
 		/// <summary>
 		/// Add multiple items to the cache
 		/// </summary>
-		public Task<bool[]> PutMultipleAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,
+		public Task<bool[]> PutManyAsync(CacheKey[] keys, object[] values, long timestamp, object[] versions, IComparer[] versionComparers,
 		                          bool[] minimalPuts, CancellationToken cancellationToken)
 		{
 			if (_batchableReadWriteCache == null)
@@ -88,8 +88,8 @@ public Task<bool[]> PutMultipleAsync(CacheKey[] keys, object[] values, long time
 			{
 				return Task.FromCanceled<bool[]>(cancellationToken);
 			}
-			return InternalPutMultipleAsync();
-			async Task<bool[]> InternalPutMultipleAsync()
+			return InternalPutManyAsync();
+			async Task<bool[]> InternalPutManyAsync()
 			{
 				var result = new bool[keys.Length];
 				if (timestamp == long.MinValue)
@@ -111,7 +111,7 @@ async Task<bool[]> InternalPutMultipleAsync()
 				var skipKeyIndexes = new HashSet<int>();
 				if (checkKeys.Any())
 				{
-					var objects = await (_batchableReadWriteCache.GetMultipleAsync(checkKeys.ToArray(), cancellationToken)).ConfigureAwait(false);
+					var objects = await (_batchableReadWriteCache.GetManyAsync(checkKeys.ToArray(), cancellationToken)).ConfigureAwait(false);
 					for (var i = 0; i < objects.Length; i++)
 					{
 						if (objects[i] != null)
@@ -143,7 +143,7 @@ async Task<bool[]> InternalPutMultipleAsync()
 					putValues[j++] = values[i];
 					result[i] = true;
 				}
-				await (_batchableReadWriteCache.PutMultipleAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);
+				await (_batchableReadWriteCache.PutManyAsync(putKeys, putValues, cancellationToken)).ConfigureAwait(false);
 				return result;
 			}
 		}