Added a generic caching provider interface

Author: johelvisguzman

src/DotNetToolkit.Repository.Caching.InMemory/InMemoryCacheProvider.cs

@@ -7,9 +7,9 @@
     using Utility;
 
     /// <summary>
-    /// An implementation of <see cref="ICacheProvider" />.
+    /// An implementation of <see cref="ICacheProvider{TCache}" />.
     /// </summary>
-    public class InMemoryCacheProvider : ICacheProvider
+    public class InMemoryCacheProvider : ICacheProvider<InMemoryCache>
     {
         #region Constructors
 
@@ -49,11 +49,23 @@ public InMemoryCacheProvider([NotNull] IMemoryCache cache, [CanBeNull] TimeSpan?
         /// Gets or sets the caching expiration time.
         /// </summary>
         public TimeSpan? Expiry { get; set; }
+        
+        /// <summary>
+        /// Gets the cache.
+        /// </summary>
+        ICache ICacheProvider.Cache
+        {
+            get { return Cache; }
+        }
+
+        #endregion
+
+        #region Implementation of ICacheProvider<TCache>
 
         /// <summary>
         /// Gets the cache.
         /// </summary>
-        public ICache Cache { get; }
+        public InMemoryCache Cache { get; }
 
         #endregion
     }

src/DotNetToolkit.Repository.Caching.Redis/RedisCache.cs

@@ -26,6 +26,14 @@ public class RedisCache : ICache
         /// </summary>
         public ConnectionMultiplexer Connection { get { return _lazyConnection.Value; } }
 
+        /// <summary>
+        /// Gets the redis server.
+        /// </summary>
+        public IServer Server
+        {
+            get { return Connection.GetServer(Connection.GetEndPoints()[0]); }
+        }
+
         /// <summary>
         /// Gets the redis database.
         /// </summary>

src/DotNetToolkit.Repository.Caching.Redis/RedisCacheProvider.cs

@@ -7,36 +7,10 @@
     using Utility;
 
     /// <summary>
-    /// An implementation of <see cref="ICacheProvider" />.
+    /// An implementation of <see cref="ICacheProvider{TCache}" />.
     /// </summary>
-    public class RedisCacheProvider : ICacheProvider
+    public class RedisCacheProvider : ICacheProvider<RedisCache>
     {
-        #region Fields
-
-        private readonly RedisCache _redis;
-
-        #endregion
-
-        #region Properties
-
-        /// <summary>
-        /// Gets the redis connection multiplexer.
-        /// </summary>
-        public ConnectionMultiplexer Connection
-        {
-            get { return _redis.Connection; }
-        }
-
-        /// <summary>
-        /// Gets the redis server.
-        /// </summary>
-        public IServer Server
-        {
-            get { return Connection.GetServer(Connection.GetEndPoints()[0]); }
-        }
-
-        #endregion
-
         #region Constructors
 
         /// <summary>
@@ -52,8 +26,7 @@ public RedisCacheProvider() : this((TimeSpan?)null) { }
         /// <remarks>This will connect to a single server on the local machine using the default redis port (6379).</remarks>
         public RedisCacheProvider([CanBeNull] TimeSpan? expiry)
         {
-            _redis = new RedisCache();
-
+            Cache = new RedisCache();
             Expiry = expiry;
         }
 
@@ -66,8 +39,7 @@ public RedisCacheProvider([CanBeNull] TimeSpan? expiry)
         /// <remarks>This will connect to a single server on the local machine using the default redis port (6379).</remarks>
         public RedisCacheProvider(bool allowAdmin, [CanBeNull] int? defaultDatabase, [CanBeNull] TimeSpan? expiry)
         {
-            _redis = new RedisCache(allowAdmin, defaultDatabase);
-
+            Cache = new RedisCache(allowAdmin, defaultDatabase);
             Expiry = expiry;
         }
 
@@ -78,10 +50,7 @@ public RedisCacheProvider(bool allowAdmin, [CanBeNull] int? defaultDatabase, [Ca
         /// <param name="expiry">The the caching expiration time.</param>
         public RedisCacheProvider([NotNull] string configuration, [CanBeNull] TimeSpan? expiry)
         {
-            Guard.NotNull(configuration, nameof(configuration));
-
-            _redis = new RedisCache(configuration);
-
+            Cache = new RedisCache(Guard.NotNull(configuration, nameof(configuration)));
             Expiry = expiry;
         }
 
@@ -92,10 +61,7 @@ public RedisCacheProvider([NotNull] string configuration, [CanBeNull] TimeSpan?
         /// <param name="expiry">The the caching expiration time.</param>
         public RedisCacheProvider([NotNull] ConfigurationOptions options, [CanBeNull] TimeSpan? expiry)
         {
-            Guard.NotNull(options, nameof(options));
-
-            _redis = new RedisCache(options);
-
+            Cache = new RedisCache(Guard.NotNull(options, nameof(options)));
             Expiry = expiry;
         }
 
@@ -111,8 +77,7 @@ public RedisCacheProvider([NotNull] string host, bool ssl, bool allowAdmin, [Can
         {
             Guard.NotEmpty(host, nameof(host));
 
-            _redis = new RedisCache(host, ssl, allowAdmin, defaultDatabase);
-
+            Cache = new RedisCache(host, ssl, allowAdmin, defaultDatabase);
             Expiry = expiry;
         }
 
@@ -131,8 +96,7 @@ public RedisCacheProvider([NotNull] string host, int port, [NotNull] string pass
             Guard.NotEmpty(host, nameof(host));
             Guard.NotEmpty(password, nameof(password));
 
-            _redis = new RedisCache(host, port, password, ssl, allowAdmin, defaultDatabase);
-
+            Cache = new RedisCache(host, port, password, ssl, allowAdmin, defaultDatabase);
             Expiry = expiry;
         }
 
@@ -148,7 +112,19 @@ public RedisCacheProvider([NotNull] string host, int port, [NotNull] string pass
         /// <summary>
         /// Gets the cache.
         /// </summary>
-        public ICache Cache { get { return _redis; } }
+        ICache ICacheProvider.Cache
+        {
+            get { return Cache; }
+        }
+
+        #endregion
+
+        #region Implementation of ICacheProvider<TCache>
+
+        /// <summary>
+        /// Gets the cache.
+        /// </summary>
+        public RedisCache Cache { get; }
 
         #endregion
     }

src/DotNetToolkit.Repository/Configuration/Caching/ICacheProvider.cs

@@ -17,4 +17,17 @@ public interface ICacheProvider
         /// </summary>
         ICache Cache { get; }
     }
+
+    /// <summary>
+    /// Represents a caching provider for caching query data within the repositories.
+    /// </summary>
+    /// <typeparam name="TCache">The type of the cache.</typeparam>
+    /// <seealso cref="ICacheProvider" />
+    public interface ICacheProvider<out TCache> : ICacheProvider where TCache : ICache
+    {
+        /// <summary>
+        /// Gets the cache.
+        /// </summary>
+        new TCache Cache { get; }
+    }
 }

src/DotNetToolkit.Repository/Configuration/Caching/Internal/NullCacheProvider.cs

@@ -3,16 +3,24 @@
     using System;
 
     /// <summary>
-    /// An implementation of <see cref="ICacheProvider" />.
+    /// An implementation of <see cref="ICacheProvider{TCache}" />.
     /// </summary>
-    internal class NullCacheProvider : ICacheProvider
+    internal class NullCacheProvider : ICacheProvider<NullCache>
     {
         internal static NullCacheProvider Instance { get; } = new NullCacheProvider();
 
-        private NullCacheProvider() { }
+        private NullCacheProvider()
+        {
+            Cache = NullCache.Instance;
+        }
 
         public TimeSpan? Expiry { get; set; }
 
-        public ICache Cache { get; } = NullCache.Instance;
+        ICache ICacheProvider.Cache
+        {
+            get { return Cache; }
+        }
+
+        public NullCache Cache { get; }
     }
 }

test/DotNetToolkit.Repository.Integration.Test/Data/TestBase.cs

@@ -248,11 +248,11 @@ private static void ApplyCachingProvider(CachingProviderType cachingProvider, Re
                     }
                 case CachingProviderType.Redis:
                     {
-                        var redis = new RedisCacheProvider(allowAdmin: true, defaultDatabase: 0, expiry: null);
+                        var provider = new RedisCacheProvider(allowAdmin: true, defaultDatabase: 0, expiry: null);
 
-                        redis.Server.FlushAllDatabases();
+                        provider.Cache.Server.FlushAllDatabases();
 
-                        builder.UseCachingProvider(redis);
+                        builder.UseCachingProvider(provider);
 
                         break;
                     }