diff --git a/Examples/ApplicationServices/Examples.ApplicationServices.CQRS/Examples.ApplicationServices.CQRS.csproj b/Examples/ApplicationServices/Examples.ApplicationServices.CQRS/Examples.ApplicationServices.CQRS.csproj
index cf1f4e63..f014f8de 100644
--- a/Examples/ApplicationServices/Examples.ApplicationServices.CQRS/Examples.ApplicationServices.CQRS.csproj
+++ b/Examples/ApplicationServices/Examples.ApplicationServices.CQRS/Examples.ApplicationServices.CQRS.csproj
@@ -10,6 +10,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\Src\RCommon.ApplicationServices\RCommon.ApplicationServices.csproj" />
     <ProjectReference Include="..\..\..\Src\RCommon.FluentValidation\RCommon.FluentValidation.csproj" />
+    <ProjectReference Include="..\..\..\Src\RCommon.MemoryCache\RCommon.MemoryCache.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/Examples/ApplicationServices/Examples.ApplicationServices.CQRS/Program.cs b/Examples/ApplicationServices/Examples.ApplicationServices.CQRS/Program.cs
index 3c176004..4b5e5c0c 100644
--- a/Examples/ApplicationServices/Examples.ApplicationServices.CQRS/Program.cs
+++ b/Examples/ApplicationServices/Examples.ApplicationServices.CQRS/Program.cs
@@ -7,6 +7,7 @@
 using RCommon.ApplicationServices;
 using RCommon.Caching;
 using RCommon.FluentValidation;
+using RCommon.MemoryCache;
 using System.Diagnostics;
 using System.Reflection;
 
@@ -32,7 +33,6 @@
                             // Or this way which uses a little magic but is simple
                             cqrs.AddCommandHandlers((typeof(Program).GetTypeInfo().Assembly));
                             cqrs.AddQueryHandlers((typeof(Program).GetTypeInfo().Assembly));
-                            cqrs.AddMemoryCachingForHandlers<IMemoryCachingBuilder>();
                         })
                         .WithValidation<FluentValidationBuilder>(validation =>
                         {
@@ -43,8 +43,17 @@
                                 options.ValidateCommands = true;
                                 options.ValidateQueries = true;
                             });
+                        })
+                        .WithMemoryCaching<InMemoryCachingBuilder>(cache =>
+                        {
+                            cache.Configure(x =>
+                            {
+                                x.ExpirationScanFrequency = TimeSpan.FromMinutes(1);
+                            });
+                            cache.CacheDynamicallyCompiledExpressions();
                         });
-                    
+
+
                     services.AddTransient<ITestApplicationService, TestApplicationService>();
                     
                 }).Build();
diff --git a/Examples/Caching/Examples.Caching.MemoryCaching/Program.cs b/Examples/Caching/Examples.Caching.MemoryCaching/Program.cs
index e59be1e8..56c4ebee 100644
--- a/Examples/Caching/Examples.Caching.MemoryCaching/Program.cs
+++ b/Examples/Caching/Examples.Caching.MemoryCaching/Program.cs
@@ -31,6 +31,7 @@
                                 x.ExpirationScanFrequency = TimeSpan.FromMinutes(1);
                             });
                             cache.CacheDynamicallyCompiledExpressions();
+
                         })
                         .WithDistributedCaching<DistributedMemoryCacheBuilder>(cache =>
                         {
diff --git a/Src/RCommon.ApplicationServices/ICqrsBuilderExtensions.cs b/Src/RCommon.ApplicationServices/ICqrsBuilderExtensions.cs
deleted file mode 100644
index fd9f4966..00000000
--- a/Src/RCommon.ApplicationServices/ICqrsBuilderExtensions.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using RCommon.Caching;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace RCommon.ApplicationServices
-{
-    public static class ICqrsBuilderExtensions
-    {
-        public static ICqrsBuilder AddMemoryCachingForHandlers<T>(this ICqrsBuilder builder)
-            where T : IMemoryCachingBuilder
-        {
-            return AddMemoryCachingForHandlers<T>(builder, x => { });
-        }
-
-        public static ICqrsBuilder AddMemoryCachingForHandlers<T>(this ICqrsBuilder builder, Action<T> actions)
-            where T : IMemoryCachingBuilder
-        {
-            Guard.IsNotNull(actions, nameof(actions));
-            var cachingConfig = (T)Activator.CreateInstance(typeof(T), new object[] { builder });
-            actions(cachingConfig);
-            return builder;
-        }
-
-        public static ICqrsBuilder AddDistributedCachingForHandlers<T>(this ICqrsBuilder builder)
-            where T : IDistributedCachingBuilder
-        {
-            return AddDistributedCachingForHandlers<T>(builder, x => { });
-        }
-
-        public static ICqrsBuilder AddDistributedCachingForHandlers<T>(this ICqrsBuilder builder, Action<T> actions)
-            where T : IDistributedCachingBuilder
-        {
-            Guard.IsNotNull(actions, nameof(actions));
-            var cachingConfig = (T)Activator.CreateInstance(typeof(T), new object[] { builder });
-            actions(cachingConfig);
-            return builder;
-        }
-    }
-}
diff --git a/Src/RCommon.MemoryCache/IDistributedMemoryCachingBuilderExtensions.cs b/Src/RCommon.MemoryCache/IDistributedMemoryCachingBuilderExtensions.cs
index 5139cb42..d4dcda72 100644
--- a/Src/RCommon.MemoryCache/IDistributedMemoryCachingBuilderExtensions.cs
+++ b/Src/RCommon.MemoryCache/IDistributedMemoryCachingBuilderExtensions.cs
@@ -24,9 +24,17 @@ public static IDistributedMemoryCachingBuilder Configure(this IDistributedMemory
         /// </summary>
         /// <param name="builder">Builder</param>
         /// <returns>Same builder to allow chaining</returns>
-        /// <remarks>The most performant way to do this is through InMemoryCache but this works fine</remarks>
+        /// <remarks>This is the most performant way to cache expressions!</remarks>
         public static IDistributedMemoryCachingBuilder CacheDynamicallyCompiledExpressions(this IDistributedMemoryCachingBuilder builder)
         {
+
+            // Add Caching services
+            builder.Services.TryAddTransient<ICacheService, DistributedMemoryCacheService>();
+            builder.Services.TryAddTransient<DistributedMemoryCacheService>();
+            builder.Services.TryAddTransient<ICommonFactory<ExpressionCachingStrategy, ICacheService>, CommonFactory<ExpressionCachingStrategy, ICacheService>>();
+            ConfigureCachingOptions(builder);
+
+            // Add Caching Factory
             builder.Services.TryAddTransient<Func<ExpressionCachingStrategy, ICacheService>>(serviceProvider => strategy =>
             {
                 switch (strategy)
@@ -37,14 +45,26 @@ public static IDistributedMemoryCachingBuilder CacheDynamicallyCompiledExpressio
                         return serviceProvider.GetService<DistributedMemoryCacheService>();
                 }
             });
-            builder.Services.TryAddTransient<ICommonFactory<ExpressionCachingStrategy, ICacheService>, CommonFactory<ExpressionCachingStrategy, ICacheService>>();
 
-            builder.Services.Configure<CachingOptions>(x =>
-            {
-                x.CachingEnabled = true;
-                x.CacheDynamicallyCompiledExpressions = true;
-            });
             return builder;
         }
+
+        private static void ConfigureCachingOptions(IDistributedMemoryCachingBuilder builder, Action<CachingOptions> configure = null)
+        {
+
+            if (configure == null)
+            {
+                builder.Services.Configure<CachingOptions>(x =>
+                {
+                    x.CachingEnabled = true;
+                    x.CacheDynamicallyCompiledExpressions = true;
+                });
+            }
+            else
+            {
+                builder.Services.Configure(configure);
+            }
+
+        }
     }
 }
diff --git a/Src/RCommon.MemoryCache/IInMemoryCachingBuilderExtensions.cs b/Src/RCommon.MemoryCache/IInMemoryCachingBuilderExtensions.cs
index 55a09805..f7ab9a40 100644
--- a/Src/RCommon.MemoryCache/IInMemoryCachingBuilderExtensions.cs
+++ b/Src/RCommon.MemoryCache/IInMemoryCachingBuilderExtensions.cs
@@ -27,6 +27,14 @@ public static IInMemoryCachingBuilder Configure(this IInMemoryCachingBuilder bui
         /// <remarks>This is the most performant way to cache expressions!</remarks>
         public static IInMemoryCachingBuilder CacheDynamicallyCompiledExpressions(this IInMemoryCachingBuilder builder)
         {
+
+            // Add Caching services
+            builder.Services.TryAddTransient<ICacheService, InMemoryCacheService>();
+            builder.Services.TryAddTransient<InMemoryCacheService>();
+            builder.Services.TryAddTransient<ICommonFactory<ExpressionCachingStrategy, ICacheService>, CommonFactory<ExpressionCachingStrategy, ICacheService>>();
+            ConfigureCachingOptions(builder);
+
+            // Add Caching Factory
             builder.Services.TryAddTransient<Func<ExpressionCachingStrategy, ICacheService>>(serviceProvider => strategy =>
             {
                 switch (strategy)
@@ -37,15 +45,26 @@ public static IInMemoryCachingBuilder CacheDynamicallyCompiledExpressions(this I
                         return serviceProvider.GetService<InMemoryCacheService>();
                 }
             });
-            builder.Services.TryAddTransient<ICacheService, InMemoryCacheService>();
-            builder.Services.TryAddTransient<ICommonFactory<ExpressionCachingStrategy, ICacheService>, CommonFactory<ExpressionCachingStrategy, ICacheService>>();
-            
-            builder.Services.Configure<CachingOptions>(x =>
-            {
-                x.CachingEnabled = true;
-                x.CacheDynamicallyCompiledExpressions = true;
-            });
+
             return builder;
         }
+
+        private static void ConfigureCachingOptions(IInMemoryCachingBuilder builder, Action<CachingOptions> configure = null)
+        {
+
+            if (configure == null)
+            {
+                builder.Services.Configure<CachingOptions>(x =>
+                {
+                    x.CachingEnabled = true;
+                    x.CacheDynamicallyCompiledExpressions = true;
+                });
+            }
+            else
+            {
+                builder.Services.Configure(configure);
+            }
+
+        }
     }
 }