Replace ICache interface by a CacheBase class

src/AsyncGenerator.yml

@@ -276,8 +276,6 @@ methodRules:
     name: Lock
   - containingType: NHibernate.Cache.ICache
     name: Unlock
-  - containingType: NHibernate.Cache.IBatchableReadOnlyCache
-  - containingType: NHibernate.Cache.IBatchableCache
   name: Cache
 - filters:
   - containingType: NHibernate.Action.IAfterTransactionCompletionProcess

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

@@ -537,17 +537,12 @@ public async Task MultiplePutReadWriteItemTestAsync()
 		public async Task UpdateTimestampsCacheTestAsync()
 		{
 			var timestamp = Sfi.UpdateTimestampsCache;
-			var fieldReadonly = typeof(UpdateTimestampsCache).GetField(
-				"_batchReadOnlyUpdateTimestamps",
-				BindingFlags.NonPublic | BindingFlags.Instance);
-			Assert.That(fieldReadonly, Is.Not.Null, "Unable to find _batchReadOnlyUpdateTimestamps field");
-			Assert.That(fieldReadonly.GetValue(timestamp), Is.Not.Null, "_batchReadOnlyUpdateTimestamps is null");
 			var field = typeof(UpdateTimestampsCache).GetField(
-				"_batchUpdateTimestamps",
+				"_updateTimestamps",
 				BindingFlags.NonPublic | BindingFlags.Instance);
-			Assert.That(field, Is.Not.Null, "Unable to find _batchUpdateTimestamps field");
+			Assert.That(field, Is.Not.Null, "Unable to find _updateTimestamps field");
 			var cache = (BatchableCache) field.GetValue(timestamp);
-			Assert.That(cache, Is.Not.Null, "_batchUpdateTimestamps is null");
+			Assert.That(cache, Is.Not.Null, "Cache field");
 
 			await (cache.ClearAsync(CancellationToken.None));
 			cache.ClearStatistics();
@@ -606,25 +601,20 @@ public async Task QueryCacheTestAsync()
 				Assert.Ignore($"{Sfi.ConnectionProvider.Driver} does not support multiple queries");
 
 			var queryCache = Sfi.GetQueryCache(null);
-			var readonlyField = typeof(StandardQueryCache).GetField(
-				"_batchableReadOnlyCache",
-				BindingFlags.NonPublic | BindingFlags.Instance);
-			Assert.That(readonlyField, Is.Not.Null, "Unable to find _batchableReadOnlyCache field");
-			Assert.That(readonlyField.GetValue(queryCache), Is.Not.Null, "_batchableReadOnlyCache is null");
 			var field = typeof(StandardQueryCache).GetField(
-				"_batchableCache",
+				"_cache",
 				BindingFlags.NonPublic | BindingFlags.Instance);
-			Assert.That(field, Is.Not.Null, "Unable to find _batchableCache field");
+			Assert.That(field, Is.Not.Null, "Unable to find _cache field");
 			var cache = (BatchableCache) field.GetValue(queryCache);
-			Assert.That(cache, Is.Not.Null, "_batchableCache is null");
+			Assert.That(cache, Is.Not.Null, "_cache is null");
 
 			var timestamp = Sfi.UpdateTimestampsCache;
 			var tsField = typeof(UpdateTimestampsCache).GetField(
-				"_batchUpdateTimestamps",
+				"_updateTimestamps",
 				BindingFlags.NonPublic | BindingFlags.Instance);
-			Assert.That(tsField, Is.Not.Null, "Unable to find _batchUpdateTimestamps field");
+			Assert.That(tsField, Is.Not.Null, "Unable to find _updateTimestamps field");
 			var tsCache = (BatchableCache) tsField.GetValue(timestamp);
-			Assert.That(tsCache, Is.Not.Null, "_batchUpdateTimestamps is null");
+			Assert.That(tsCache, Is.Not.Null, "_updateTimestamps is null");
 
 			await (cache.ClearAsync(CancellationToken.None));
 			cache.ClearStatistics();

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

@@ -34,7 +34,7 @@ private CacheKey CreateCacheKey(string text)
 
 		public async Task DoTestCacheAsync(ICacheProvider cacheProvider, CancellationToken cancellationToken = default(CancellationToken))
 		{
-			ICache cache = cacheProvider.BuildCache(typeof(String).FullName, new Dictionary<string, string>());
+			var cache = cacheProvider.BuildCache(typeof(String).FullName, new Dictionary<string, string>());
 
 			long longBefore = Timestamper.Next();
 
@@ -141,7 +141,7 @@ private CacheKey CreateCacheKey(string text)
 			Assert.AreEqual("baz", await (ccs.GetAsync(fooKey, longLongAfter, cancellationToken)));
 		}
 
-		private async Task DoTestMinValueTimestampOnStrategyAsync(ICache cache, ICacheConcurrencyStrategy strategy, CancellationToken cancellationToken = default(CancellationToken))
+		private async Task DoTestMinValueTimestampOnStrategyAsync(CacheBase cache, ICacheConcurrencyStrategy strategy, CancellationToken cancellationToken = default(CancellationToken))
 		{
 			CacheKey key = CreateCacheKey("key");
 			strategy.Cache = cache;
@@ -154,7 +154,7 @@ private CacheKey CreateCacheKey(string text)
 		[Test]
 		public async Task MinValueTimestampAsync()
 		{
-			ICache cache = new HashtableCacheProvider().BuildCache("region", new Dictionary<string, string>());
+			var cache = new HashtableCacheProvider().BuildCache("region", new Dictionary<string, string>());
 			ICacheConcurrencyStrategy strategy = new ReadWriteCache();
 			strategy.Cache = cache;
 
@@ -163,4 +163,4 @@ public async Task MinValueTimestampAsync()
 			await (DoTestMinValueTimestampOnStrategyAsync(cache, new ReadOnlyCache()));
 		}
 	}
-}
+}

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

@@ -8,21 +8,36 @@
 //------------------------------------------------------------------------------
 
 
-using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using NHibernate.Cache;
 
 namespace NHibernate.Test.CacheTest.Caches
 {
-	public partial class BatchableCache : ICache, IBatchableCache
+	using System.Threading.Tasks;
+	using System.Threading;
+	public partial class BatchableCache : CacheBase
 	{
 
-		public Task PutManyAsync(object[] keys, object[] values, CancellationToken cancellationToken)
+		public override Task<object[]> GetManyAsync(object[] keys, CancellationToken cancellationToken)
+		{
+			try
+			{
+				GetMultipleCalls.Add(keys);
+				var result = new object[keys.Length];
+				for (var i = 0; i < keys.Length; i++)
+				{
+					result[i] = _hashtable[keys[i]];
+				}
+				return Task.FromResult<object[]>(result);
+			}
+			catch (System.Exception ex)
+			{
+				return Task.FromException<object[]>(ex);
+			}
+		}
+
+		public override Task PutManyAsync(object[] keys, object[] values, CancellationToken cancellationToken)
 		{
 			try
 			{
@@ -33,130 +48,101 @@ public Task PutManyAsync(object[] keys, object[] values, CancellationToken cance
 				}
 				return Task.CompletedTask;
 			}
-			catch (Exception ex)
+			catch (System.Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
 		}
 
-		public Task<object> LockManyAsync(object[] keys, CancellationToken cancellationToken)
+		public override Task<object> LockManyAsync(object[] keys, CancellationToken cancellationToken)
 		{
 			try
 			{
 				LockMultipleCalls.Add(keys);
 				return Task.FromResult<object>(null);
 			}
-			catch (Exception ex)
+			catch (System.Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
 		}
 
-		public Task UnlockManyAsync(object[] keys, object lockValue, CancellationToken cancellationToken)
+		public override Task UnlockManyAsync(object[] keys, object lockValue, CancellationToken cancellationToken)
 		{
 			try
 			{
 				UnlockMultipleCalls.Add(keys);
 				return Task.CompletedTask;
 			}
-			catch (Exception ex)
+			catch (System.Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
 		}
 
-		#region ICache Members
-
-		/// <summary></summary>
-		public Task<object> GetAsync(object key, CancellationToken cancellationToken)
+		public override Task<object> GetAsync(object key, CancellationToken cancellationToken)
 		{
 			try
 			{
 				GetCalls.Add(key);
 				return Task.FromResult<object>(_hashtable[key]);
 			}
-			catch (Exception ex)
+			catch (System.Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
 		}
 
-		public Task<object[]> GetManyAsync(object[] keys, CancellationToken cancellationToken)
-		{
-			try
-			{
-				GetMultipleCalls.Add(keys);
-				var result = new object[keys.Length];
-				for (var i = 0; i < keys.Length; i++)
-				{
-					result[i] = _hashtable[keys[i]];
-				}
-				return Task.FromResult<object[]>(result);
-			}
-			catch (Exception ex)
-			{
-				return Task.FromException<object[]>(ex);
-			}
-		}
-
-		/// <summary></summary>
-		public Task PutAsync(object key, object value, CancellationToken cancellationToken)
+		public override Task PutAsync(object key, object value, CancellationToken cancellationToken)
 		{
 			try
 			{
 				PutCalls.Add(key);
 				_hashtable[key] = value;
 				return Task.CompletedTask;
 			}
-			catch (Exception ex)
+			catch (System.Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
 		}
 
-		/// <summary></summary>
-		public Task RemoveAsync(object key, CancellationToken cancellationToken)
+		public override Task RemoveAsync(object key, CancellationToken cancellationToken)
 		{
 			try
 			{
 				_hashtable.Remove(key);
 				return Task.CompletedTask;
 			}
-			catch (Exception ex)
+			catch (System.Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
 		}
 
-		/// <summary></summary>
-		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
-		public Task ClearAsync(CancellationToken cancellationToken)
+		public override Task ClearAsync(CancellationToken cancellationToken)
 		{
 			try
 			{
 				_hashtable.Clear();
 				return Task.CompletedTask;
 			}
-			catch (Exception ex)
+			catch (System.Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
 		}
 
-		/// <summary></summary>
-		public Task LockAsync(object key, CancellationToken cancellationToken)
+		public override Task<object> LockAsync(object key, CancellationToken cancellationToken)
 		{
-			return Task.CompletedTask;
-			// local cache, so we use synchronization
+			// local cache, no need to actually lock.
+			return Task.FromResult<object>(null);
 		}
 
-		/// <summary></summary>
-		public Task UnlockAsync(object key, CancellationToken cancellationToken)
+		public override Task UnlockAsync(object key, object lockValue, CancellationToken cancellationToken)
 		{
 			return Task.CompletedTask;
-			// local cache, so we use synchronization
+			// local cache, no need to actually lock.
 		}
-
-		#endregion
 	}
 }

src/NHibernate.Test/Async/NHSpecificTest/NH2898/BinaryFormatterCache.cs

@@ -12,16 +12,18 @@
 using System.IO;
 using System.Runtime.Serialization.Formatters.Binary;
 using NHibernate.Cache;
+#if !NETFX
 using NHibernate.Util;
+#endif
 
 namespace NHibernate.Test.NHSpecificTest.NH2898
 {
 	using System.Threading.Tasks;
 	using System.Threading;
-	public partial class BinaryFormatterCache : ICache
+	public partial class BinaryFormatterCache : CacheBase
 	{
 
-		public Task<object> GetAsync(object key, CancellationToken cancellationToken)
+		public override Task<object> GetAsync(object key, CancellationToken cancellationToken)
 		{
 			try
 			{
@@ -46,7 +48,7 @@ public Task<object> GetAsync(object key, CancellationToken cancellationToken)
 			}
 		}
 
-		public Task PutAsync(object key, object value, CancellationToken cancellationToken)
+		public override Task PutAsync(object key, object value, CancellationToken cancellationToken)
 		{
 			try
 			{
@@ -69,7 +71,7 @@ public Task PutAsync(object key, object value, CancellationToken cancellationTok
 			}
 		}
 
-		public Task RemoveAsync(object key, CancellationToken cancellationToken)
+		public override Task RemoveAsync(object key, CancellationToken cancellationToken)
 		{
 			try
 			{
@@ -82,7 +84,7 @@ public Task RemoveAsync(object key, CancellationToken cancellationToken)
 			}
 		}
 
-		public Task ClearAsync(CancellationToken cancellationToken)
+		public override Task ClearAsync(CancellationToken cancellationToken)
 		{
 			try
 			{
@@ -95,16 +97,16 @@ public Task ClearAsync(CancellationToken cancellationToken)
 			}
 		}
 
-		public Task LockAsync(object key, CancellationToken cancellationToken)
+		public override Task<object> LockAsync(object key, CancellationToken cancellationToken)
 		{
-			return Task.CompletedTask;
 			// local cache, so we use synchronization
+			return Task.FromResult<object>(null);
 		}
 
-		public Task UnlockAsync(object key, CancellationToken cancellationToken)
+		public override Task UnlockAsync(object key, object lockValue, CancellationToken cancellationToken)
 		{
 			return Task.CompletedTask;
 			// local cache, so we use synchronization
 		}
 	}
-}
+}