Introduced MemoryCacheOptions for ICachingConfiguration

doc/WebSite/Caching.md

@@ -106,6 +106,17 @@ first request). Configuration is not restricted to
 DefaultSlidingExpireTime only, since the cache object is an **ICacheOptions**, you can
 use it's properties to freely configure and initialize it.
 
+#### MemoryCache Configuration
+
+You can configure memory cache options using ASP.NET Core's options pattern as shown below;
+
+```csharp
+Configuration.Caching.MemoryCacheOptions = new MemoryCacheOptions
+{
+    SizeLimit = 2048
+};
+```
+
 ### Entity Caching
 
 While ASP.NET Boilerplate's cache system is for general purposes, there is an

src/Abp/Runtime/Caching/Configuration/CachingConfiguration.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using Abp.Configuration.Startup;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace Abp.Runtime.Caching.Configuration
 {
@@ -13,6 +14,9 @@ public IReadOnlyList<ICacheConfigurator> Configurators
         {
             get { return _configurators.ToImmutableList(); }
         }
+
+        public MemoryCacheOptions MemoryCacheOptions { get; set; }
+
         private readonly List<ICacheConfigurator> _configurators;
 
         public CachingConfiguration(IAbpStartupConfiguration abpConfiguration)

src/Abp/Runtime/Caching/Configuration/ICachingConfiguration.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Abp.Configuration.Startup;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace Abp.Runtime.Caching.Configuration
 {
@@ -19,6 +20,11 @@ public interface ICachingConfiguration
         /// </summary>
         IReadOnlyList<ICacheConfigurator> Configurators { get; }
 
+        /// <summary>
+        /// Options for memory cache
+        /// </summary>
+        MemoryCacheOptions MemoryCacheOptions { get; set; }
+
         /// <summary>
         /// Used to configure all caches.
         /// </summary>

src/Abp/Runtime/Caching/Memory/AbpMemoryCache.cs

@@ -11,15 +11,20 @@ namespace Abp.Runtime.Caching.Memory
     public class AbpMemoryCache : CacheBase
     {
         private MemoryCache _memoryCache;
-
+        private readonly MemoryCacheOptions _memoryCacheOptions;
+
         /// <summary>
         /// Constructor.
         /// </summary>
         /// <param name="name">Unique name of the cache</param>
-        public AbpMemoryCache(string name)
+        /// <param name="memoryCacheOptions">MemoryCacheOptions</param>
+        public AbpMemoryCache(string name, MemoryCacheOptions memoryCacheOptions = null)
             : base(name)
         {
-            _memoryCache = new MemoryCache(new OptionsWrapper<MemoryCacheOptions>(new MemoryCacheOptions()));
+            _memoryCacheOptions = memoryCacheOptions;
+            _memoryCache = new MemoryCache(new OptionsWrapper<MemoryCacheOptions>(
+                memoryCacheOptions ?? new MemoryCacheOptions()
+            ));
         }
 
         public override bool TryGetValue(string key, out object value)
@@ -64,7 +69,9 @@ public override void Remove(string key)
         public override void Clear()
         {
             _memoryCache.Dispose();
-            _memoryCache = new MemoryCache(new OptionsWrapper<MemoryCacheOptions>(new MemoryCacheOptions()));
+            _memoryCache = new MemoryCache(new OptionsWrapper<MemoryCacheOptions>(
+                _memoryCacheOptions ?? new MemoryCacheOptions()
+            ));
         }
 
         public override void Dispose()

src/Abp/Runtime/Caching/Memory/AbpMemoryCacheManager.cs

@@ -1,5 +1,9 @@
-using Abp.Runtime.Caching.Configuration;
+using System.Linq;
+using Abp.Dependency;
+using Abp.Runtime.Caching.Configuration;
 using Castle.Core.Logging;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
 
 namespace Abp.Runtime.Caching.Memory
 {
@@ -9,7 +13,7 @@ namespace Abp.Runtime.Caching.Memory
     public class AbpMemoryCacheManager : CacheManagerBase<ICache>, ICacheManager
     {
         public ILogger Logger { get; set; }
-
+        
         /// <summary>
         /// Constructor.
         /// </summary>
@@ -21,7 +25,7 @@ public AbpMemoryCacheManager(ICachingConfiguration configuration)
 
         protected override ICache CreateCacheImplementation(string name)
         {
-            return new AbpMemoryCache(name)
+            return new AbpMemoryCache(name, Configuration?.AbpConfiguration?.Caching?.MemoryCacheOptions)
             {
                 Logger = Logger
             };

test/aspnet-core-demo/AbpAspNetCoreDemo.Tests/Tests/MemoryCacheOptions_Test.cs

@@ -0,0 +1,43 @@
+using System.Linq;
+using Abp.Dependency;
+using Abp.Runtime.Caching;
+using Abp.Runtime.Caching.Memory;
+using AutoMapper.Internal;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+using Shouldly;
+using Xunit;
+
+namespace AbpAspNetCoreDemo.IntegrationTests.Tests
+{
+    public class MemoryCacheOptions_Test: IClassFixture<WebApplicationFactory<Startup>>
+    {
+        private readonly WebApplicationFactory<Startup> _applicationFactory;
+
+        public MemoryCacheOptions_Test()
+        {
+            _applicationFactory = new WebApplicationFactory<Startup>();
+            _applicationFactory.CreateClient();
+        }
+
+        [Fact]
+        public void MemoryCacheOption_Size_Test()
+        {
+            var memoryCacheManager = _applicationFactory.Services.GetService(typeof(ICacheManager)) as ICacheManager;
+
+            memoryCacheManager.ShouldNotBeNull();
+            memoryCacheManager.GetType().ShouldBe(typeof(AbpMemoryCacheManager));
+
+            var memoryCache= memoryCacheManager.GetCache("Test");
+
+            memoryCache.ShouldNotBeNull();
+            memoryCache.GetType().ShouldBe(typeof(AbpMemoryCache));
+
+            var memberPath =  ReflectionHelper.GetMemberPath(typeof(AbpMemoryCache), "_memoryCacheOptions").First();
+            var memoryCacheOptions = memberPath.GetMemberValue(memoryCache) as IOptions<MemoryCacheOptions>;
+            memoryCacheOptions.ShouldNotBeNull();
+            memoryCacheOptions.Value.SizeLimit.ShouldBe(2048);
+        }
+    }
+}

test/aspnet-core-demo/AbpAspNetCoreDemo/AbpAspNetCoreDemoModule.cs

@@ -17,6 +17,7 @@
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace AbpAspNetCoreDemo
 {
@@ -50,6 +51,11 @@ public override void PreInitialize()
                 endpoints.MapRazorPages();
             });
 
+            Configuration.Caching.MemoryCacheOptions = new MemoryCacheOptions
+            {
+                SizeLimit = 2048
+            };
+
             ConfigurationAction.Value?.Invoke(Configuration);
         }
 

test/aspnet-core-demo/AbpAspNetCoreDemo/Startup.cs

@@ -19,6 +19,7 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.OData;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;