Added the ability to set the default configuration options by a static property

Author: maca88

StackExRedis/NHibernate.Caches.StackExRedis.Tests/RedisCacheProviderFixture.cs

@@ -55,6 +55,37 @@ public void TestExpiration()
 				"unexpected expiration value for noExplicitExpiration region with cache.default_expiration");
 		}
 
+		[Test]
+		public void TestDefaultCacheConfiguration()
+		{
+			var connectionProvider = Substitute.For<IConnectionMultiplexerProvider>();
+			var databaseProvider = Substitute.For<IDatabaseProvider>();
+			var retryDelayProvider = Substitute.For<ICacheLockRetryDelayProvider>();
+			var lockValueProvider = Substitute.For<ICacheLockValueProvider>();
+			var regionStrategyFactory = Substitute.For<ICacheRegionStrategyFactory>();
+			var serialzer = Substitute.For<IRedisSerializer>();
+
+			var defaultConfig = RedisCacheProvider.DefaultCacheConfiguration;
+			defaultConfig.ConnectionMultiplexerProvider = connectionProvider;
+			defaultConfig.DatabaseProvider = databaseProvider;
+			defaultConfig.LockConfiguration.ValueProvider = lockValueProvider;
+			defaultConfig.LockConfiguration.RetryDelayProvider = retryDelayProvider;
+			defaultConfig.RegionStrategyFactory = regionStrategyFactory;
+			defaultConfig.Serializer = serialzer;
+
+			var provider = (RedisCacheProvider) GetNewProvider();
+			var config = provider.CacheConfiguration;
+
+			Assert.That(config.ConnectionMultiplexerProvider, Is.EqualTo(connectionProvider));
+			Assert.That(config.DatabaseProvider, Is.EqualTo(databaseProvider));
+			Assert.That(config.LockConfiguration.RetryDelayProvider, Is.EqualTo(retryDelayProvider));
+			Assert.That(config.LockConfiguration.ValueProvider, Is.EqualTo(lockValueProvider));
+			Assert.That(config.RegionStrategyFactory, Is.EqualTo(regionStrategyFactory));
+			Assert.That(config.Serializer, Is.EqualTo(serialzer));
+
+			RedisCacheProvider.DefaultCacheConfiguration = new RedisCacheConfiguration();
+		}
+
 		[Test]
 		public void TestUserProvidedObjectsFactory()
 		{
@@ -63,31 +94,31 @@ public void TestUserProvidedObjectsFactory()
 				BindingFlags.Instance | BindingFlags.NonPublic);
 
 			var customObjectsFactory = new CustomObjectsFactory();
+			var connectionProvider = Substitute.For<IConnectionMultiplexerProvider>();
+			var databaseProvider = Substitute.For<IDatabaseProvider>();
+			var retryDelayProvider = Substitute.For<ICacheLockRetryDelayProvider>();
+			var lockValueProvider = Substitute.For<ICacheLockValueProvider>();
 			var regionStrategyFactory = Substitute.For<ICacheRegionStrategyFactory>();
 			var serialzer = Substitute.For<IRedisSerializer>();
-			var lockValueProvider = Substitute.For<ICacheLockValueProvider>();
-			var retryDelayProvider = Substitute.For<ICacheLockRetryDelayProvider>();
-			var databaseProvider = Substitute.For<IDatabaseProvider>();
-			var connectionProvider = Substitute.For<IConnectionMultiplexerProvider>();
 
-			customObjectsFactory.RegisterSingleton(serialzer);
+			customObjectsFactory.RegisterSingleton(connectionProvider);
+			customObjectsFactory.RegisterSingleton(databaseProvider);
+			customObjectsFactory.RegisterSingleton(retryDelayProvider);
 			customObjectsFactory.RegisterSingleton(lockValueProvider);
 			customObjectsFactory.RegisterSingleton(regionStrategyFactory);
-			customObjectsFactory.RegisterSingleton(retryDelayProvider);
-			customObjectsFactory.RegisterSingleton(databaseProvider);
-			customObjectsFactory.RegisterSingleton(connectionProvider);
+			customObjectsFactory.RegisterSingleton(serialzer);
 
 			field.SetValue(Cfg.Environment.BytecodeProvider, customObjectsFactory);
 
 			var provider = (RedisCacheProvider)GetNewProvider();
 			var config = provider.CacheConfiguration;
 
-			Assert.That(regionStrategyFactory, Is.EqualTo(config.RegionStrategyFactory));
-			Assert.That(serialzer, Is.EqualTo(config.Serializer));
-			Assert.That(lockValueProvider, Is.EqualTo(config.LockConfiguration.ValueProvider));
-			Assert.That(retryDelayProvider, Is.EqualTo(config.LockConfiguration.RetryDelayProvider));
-			Assert.That(databaseProvider, Is.EqualTo(config.DatabaseProvider));
-			Assert.That(connectionProvider, Is.EqualTo(config.ConnectionMultiplexerProvider));
+			Assert.That(config.ConnectionMultiplexerProvider, Is.EqualTo(connectionProvider));
+			Assert.That(config.DatabaseProvider, Is.EqualTo(databaseProvider));
+			Assert.That(config.LockConfiguration.RetryDelayProvider, Is.EqualTo(retryDelayProvider));
+			Assert.That(config.LockConfiguration.ValueProvider, Is.EqualTo(lockValueProvider));
+			Assert.That(config.RegionStrategyFactory, Is.EqualTo(regionStrategyFactory));
+			Assert.That(config.Serializer, Is.EqualTo(serialzer));
 
 			field.SetValue(Cfg.Environment.BytecodeProvider, new ActivatorObjectsFactory());
 		}

StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheConfiguration.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace NHibernate.Caches.StackExRedis
 {
@@ -11,10 +7,26 @@ namespace NHibernate.Caches.StackExRedis
 	/// </summary>
 	public class RedisCacheConfiguration
 	{
+		private static readonly IRedisSerializer DefaultSerializer = new BinaryRedisSerializer();
+		private static readonly ICacheRegionStrategyFactory DefaultRegionStrategyFactory = new DefaultCacheRegionStrategyFactory();
+		private static readonly IConnectionMultiplexerProvider DefaultConnectionMultiplexerProvider = new DefaultConnectionMultiplexerProvider();
+		private static readonly IDatabaseProvider DefaultDatabaseProvider = new DefaultDatabaseProvider();
+		private static readonly System.Type DefaultRegionStrategyType = typeof(DefaultRegionStrategy);
+
+		private IRedisSerializer _serializer;
+		private ICacheRegionStrategyFactory _regionStrategyFactory;
+		private IConnectionMultiplexerProvider _connectionMultiplexerProvider;
+		private IDatabaseProvider _databaseProvider;
+		private System.Type _defaultRegionStrategy;
+
 		/// <summary>
 		/// The <see cref="IRedisSerializer"/> instance.
 		/// </summary>
-		public IRedisSerializer Serializer { get; set; } = new BinaryRedisSerializer();
+		public IRedisSerializer Serializer
+		{
+			get => _serializer ?? DefaultSerializer;
+			set => _serializer = value;
+		}
 
 		/// <summary>
 		/// The prefix that will be prepended before each cache key in order to avoid having collisions when multiple clients
@@ -57,22 +69,38 @@ public class RedisCacheConfiguration
 		/// <summary>
 		/// The <see cref="ICacheRegionStrategyFactory"/> instance.
 		/// </summary>
-		public ICacheRegionStrategyFactory RegionStrategyFactory { get; set; } = new DefaultCacheRegionStrategyFactory();
+		public ICacheRegionStrategyFactory RegionStrategyFactory
+		{
+			get => _regionStrategyFactory ?? DefaultRegionStrategyFactory;
+			set => _regionStrategyFactory = value;
+		}
 
 		/// <summary>
 		/// The <see cref="IConnectionMultiplexerProvider"/> instance.
 		/// </summary>
-		public IConnectionMultiplexerProvider ConnectionMultiplexerProvider { get; set; } = new DefaultConnectionMultiplexerProvider();
+		public IConnectionMultiplexerProvider ConnectionMultiplexerProvider
+		{
+			get => _connectionMultiplexerProvider ?? DefaultConnectionMultiplexerProvider;
+			set => _connectionMultiplexerProvider = value;
+		}
 
 		/// <summary>
 		/// The <see cref="IDatabaseProvider"/> instance.
 		/// </summary>
-		public IDatabaseProvider DatabaseProvider { get; set; } = new DefaultDatabaseProvider();
+		public IDatabaseProvider DatabaseProvider
+		{
+			get => _databaseProvider ?? DefaultDatabaseProvider;
+			set => _databaseProvider = value;
+		}
 
 		/// <summary>
 		/// The default <see cref="AbstractRegionStrategy"/> type.
 		/// </summary>
-		public System.Type DefaultRegionStrategy { get; set; } = typeof(DefaultRegionStrategy);
+		public System.Type DefaultRegionStrategy
+		{
+			get => _defaultRegionStrategy ?? DefaultRegionStrategyType;
+			set => _defaultRegionStrategy = value;
+		}
 
 		/// <summary>
 		/// The configuration for locking keys.

StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheLockConfiguration.cs

@@ -8,6 +8,12 @@ namespace NHibernate.Caches.StackExRedis
 	/// </summary>
 	public class RedisCacheLockConfiguration
 	{
+		private static readonly ICacheLockValueProvider DefaultValueProvider = new DefaultCacheLockValueProvider();
+		private static readonly ICacheLockRetryDelayProvider DefaultRetryDelayProvider = new DefaultCacheLockRetryDelayProvider();
+
+		private ICacheLockValueProvider _valueProvider;
+		private ICacheLockRetryDelayProvider _retryDelayProvider;
+
 		/// <summary>
 		/// The timeout for a lock key to expire.
 		/// </summary>
@@ -41,12 +47,20 @@ public class RedisCacheLockConfiguration
 		/// <summary>
 		/// The <see cref="ICacheLockValueProvider"/> instance.
 		/// </summary>
-		public ICacheLockValueProvider ValueProvider { get; set; } = new DefaultCacheLockValueProvider();
+		public ICacheLockValueProvider ValueProvider
+		{
+			get => _valueProvider ?? DefaultValueProvider;
+			set => _valueProvider = value;
+		}
 
 		/// <summary>
 		/// The <see cref="ICacheLockRetryDelayProvider"/> instance.
 		/// </summary>
-		public ICacheLockRetryDelayProvider RetryDelayProvider { get; set; } = new DefaultCacheLockRetryDelayProvider();
+		public ICacheLockRetryDelayProvider RetryDelayProvider
+		{
+			get => _retryDelayProvider ?? DefaultRetryDelayProvider;
+			set => _retryDelayProvider = value;
+		}
 
 		/// <inheritdoc />
 		public override string ToString()

StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheProvider.cs

@@ -15,9 +15,19 @@ public class RedisCacheProvider : ICacheProvider
 		private static readonly INHibernateLogger Log;
 		private static readonly Dictionary<string, RegionConfig> ConfiguredCacheRegions;
 		private static readonly CacheConfig ConfiguredCache;
+		private static RedisCacheConfiguration _defaultCacheConfiguration = new RedisCacheConfiguration();
 
 		private IConnectionMultiplexer _connectionMultiplexer;
 
+		/// <summary>
+		/// The default configuration that will be used for creating the <see cref="CacheConfiguration"/>.
+		/// </summary>
+		public static RedisCacheConfiguration DefaultCacheConfiguration
+		{
+			get => _defaultCacheConfiguration;
+			set => _defaultCacheConfiguration = value ?? new RedisCacheConfiguration();
+		}
+
 		static RedisCacheProvider()
 		{
 			Log = NHibernateLogger.For(typeof(RedisCacheProvider));
@@ -33,10 +43,42 @@ static RedisCacheProvider()
 			}
 		}
 
+		private static RedisCacheConfiguration CreateCacheConfiguration()
+		{
+			var defaultConfiguration = DefaultCacheConfiguration;
+			var defaultLockConfiguration = defaultConfiguration.LockConfiguration;
+			return new RedisCacheConfiguration
+			{
+				DefaultRegionStrategy = defaultConfiguration.DefaultRegionStrategy,
+				DatabaseProvider = defaultConfiguration.DatabaseProvider,
+				ConnectionMultiplexerProvider = defaultConfiguration.ConnectionMultiplexerProvider,
+				RegionPrefix = defaultConfiguration.RegionPrefix,
+				LockConfiguration =
+				{
+					RetryTimes = defaultLockConfiguration.RetryTimes,
+					RetryDelayProvider = defaultLockConfiguration.RetryDelayProvider,
+					MaxRetryDelay = defaultLockConfiguration.MaxRetryDelay,
+					ValueProvider = defaultLockConfiguration.ValueProvider,
+					KeyTimeout = defaultLockConfiguration.KeyTimeout,
+					AcquireTimeout = defaultLockConfiguration.AcquireTimeout,
+					KeySuffix = defaultLockConfiguration.KeySuffix,
+					MinRetryDelay = defaultLockConfiguration.MinRetryDelay
+				},
+				Serializer = defaultConfiguration.Serializer,
+				RegionStrategyFactory = defaultConfiguration.RegionStrategyFactory,
+				CacheKeyPrefix = defaultConfiguration.CacheKeyPrefix,
+				DefaultUseSlidingExpiration = defaultConfiguration.DefaultUseSlidingExpiration,
+				DefaultExpiration = defaultConfiguration.DefaultExpiration,
+				DefaultDatabase = defaultConfiguration.DefaultDatabase,
+				DefaultAppendHashcode = defaultConfiguration.DefaultAppendHashcode,
+				EnvironmentName = defaultConfiguration.EnvironmentName
+			};
+		}
+
 		/// <summary>
 		/// The Redis cache configuration that is populated by the NHibernate configuration.
 		/// </summary>
-		public RedisCacheConfiguration CacheConfiguration { get; } = new RedisCacheConfiguration();
+		public RedisCacheConfiguration CacheConfiguration { get; } = CreateCacheConfiguration();
 
 		/// <inheritdoc />
 		public ICache BuildCache(string regionName, IDictionary<string, string> properties)

StackExRedis/NHibernate.Caches.StackExRedis/RedisCacheRegionConfiguration.cs

@@ -35,58 +35,58 @@ public RedisCacheRegionConfiguration(string regionName)
 		/// The name of the environment that will be prepended before each cache key in order to allow having
 		/// multiple environments on the same Redis database.
 		/// </summary>
-		public string EnvironmentName { get; set; }
+		public string EnvironmentName { get; internal set; }
 
 		/// <summary>
 		/// The prefix that will be prepended before each cache key in order to avoid having collisions when multiple clients
 		/// uses the same Redis database.
 		/// </summary>
-		public string CacheKeyPrefix { get; set; }
+		public string CacheKeyPrefix { get; internal set; }
 
 		/// <summary>
 		/// The expiration time for the keys to expire.
 		/// </summary>
-		public TimeSpan Expiration { get; set; }
+		public TimeSpan Expiration { get; internal set; }
 
 		/// <summary>
 		/// The prefix that will be prepended before the region name when building a cache key.
 		/// </summary>
-		public string RegionPrefix { get; set; }
+		public string RegionPrefix { get; internal set; }
 
 		/// <summary>
 		/// The Redis database index.
 		/// </summary>
-		public int Database { get; set; }
+		public int Database { get; internal set; }
 
 		/// <summary>
 		/// Whether the expiration is sliding or not.
 		/// </summary>
-		public bool UseSlidingExpiration { get; set; }
+		public bool UseSlidingExpiration { get; internal set; }
 
 		/// <summary>
 		/// The <see cref="AbstractRegionStrategy"/> type.
 		/// </summary>
-		public System.Type RegionStrategy { get; set; }
+		public System.Type RegionStrategy { get; internal set; }
 
 		/// <summary>
 		/// Whether the hash code of the key should be added to the cache key.
 		/// </summary>
-		public bool AppendHashcode { get; set; }
+		public bool AppendHashcode { get; internal set; }
 
 		/// <summary>
 		/// The <see cref="IRedisSerializer"/> to be used.
 		/// </summary>
-		public IRedisSerializer Serializer { get; set; }
+		public IRedisSerializer Serializer { get; internal set; }
 
 		/// <summary>
 		/// The <see cref="IDatabaseProvider"/> instance.
 		/// </summary>
-		public IDatabaseProvider DatabaseProvider { get; set; } = new DefaultDatabaseProvider();
+		public IDatabaseProvider DatabaseProvider { get; internal set; }
 
 		/// <summary>
 		/// The configuration for locking keys.
 		/// </summary>
-		public RedisCacheLockConfiguration LockConfiguration { get; set; }
+		public RedisCacheLockConfiguration LockConfiguration { get; internal set; }
 
 		/// <inheritdoc />
 		public override string ToString()