Merge branch 'dev' of https://github.com/abpframework/abp into dev

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/DependencyInjection/AbpAspNetCoreMvcConventionalDependencyRegistrar.cs

@@ -9,22 +9,36 @@ namespace Volo.Abp.AspNetCore.Mvc.DependencyInjection
 {
     public class AbpAspNetCoreMvcConventionalRegistrar : DefaultConventionalRegistrar
     {
-        protected override ServiceLifetime? GetServiceLifetimeFromClassHierarcy(Type type)
+        public override void AddType(IServiceCollection services, Type type)
         {
-            var lifeTime = base.GetServiceLifetimeFromClassHierarcy(type);
-            if (lifeTime != null)
+            if (!IsMvcService(type))
             {
-                return lifeTime;
+                return;
             }
 
-            if (IsController(type) ||
-                IsPageModel(type) ||
-                IsViewComponent(type))
+            var lifeTime = GetMvcServiceLifetime(type);
+
+            var serviceTypes = ExposedServiceExplorer.GetExposedServices(type);
+
+            TriggerServiceExposing(services, type, serviceTypes);
+
+            foreach (var serviceType in serviceTypes)
             {
-                return ServiceLifetime.Transient;
+                var serviceDescriptor = ServiceDescriptor.Describe(serviceType, type, lifeTime);
+                services.Add(serviceDescriptor);
             }
+        }
 
-            return null;
+        protected virtual bool IsMvcService(Type type)
+        {
+            return IsController(type) ||
+                   IsPageModel(type) ||
+                   IsViewComponent(type);
+        }
+
+        protected virtual ServiceLifetime GetMvcServiceLifetime(Type type)
+        {
+            return ServiceLifetime.Transient;
         }
 
         private static bool IsPageModel(Type type)

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/Builder/AbpApplicationBuilderExtensions.cs

@@ -4,6 +4,7 @@ using System.Globalization;
 using System.Linq;
 using JetBrains.Annotations;
 using Microsoft.AspNetCore.Localization;
+using Microsoft.AspNetCore.RequestLocalization;
 using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp;
 using Volo.Abp.AspNetCore.Auditing;
@@ -50,40 +51,8 @@ namespace Microsoft.AspNetCore.Builder
 
         public static IApplicationBuilder UseAbpRequestLocalization(this IApplicationBuilder app, Action<RequestLocalizationOptions> optionsAction = null)
         {
-            IReadOnlyList<LanguageInfo> languages;
-            string defaultLanguage;
-
-            using (var scope = app.ApplicationServices.CreateScope())
-            {
-                var languageProvider = scope.ServiceProvider.GetRequiredService<ILanguageProvider>();
-                languages = AsyncHelper.RunSync(() => languageProvider.GetLanguagesAsync());
-
-                var settingProvider = scope.ServiceProvider.GetRequiredService<ISettingProvider>();
-                defaultLanguage = AsyncHelper.RunSync(() => settingProvider.GetOrNullAsync(LocalizationSettingNames.DefaultLanguage));
-            }
-
-            var options = !languages.Any()
-                ? new RequestLocalizationOptions()
-                : new RequestLocalizationOptions
-                {
-                    DefaultRequestCulture = DefaultGetRequestCulture(defaultLanguage, languages),
-
-                    SupportedCultures = languages
-                        .Select(l => l.CultureName)
-                        .Distinct()
-                        .Select(c => new CultureInfo(c))
-                        .ToArray(),
-
-                    SupportedUICultures = languages
-                        .Select(l => l.UiCultureName)
-                        .Distinct()
-                        .Select(c => new CultureInfo(c))
-                        .ToArray()
-                };
-
-            optionsAction?.Invoke(options);
-
-            return app.UseRequestLocalization(options);
+            app.ApplicationServices.GetRequiredService<IAbpRequestLocalizationOptionsProvider>().InitLocalizationOptions(optionsAction);
+            return app.UseMiddleware<AbpRequestLocalizationMiddleware>();
         }
 
         public static IApplicationBuilder UseAbpExceptionHandling(this IApplicationBuilder app)
@@ -96,17 +65,5 @@ namespace Microsoft.AspNetCore.Builder
             app.Properties[ExceptionHandlingMiddlewareMarker] = true;
             return app.UseMiddleware<AbpExceptionHandlingMiddleware>();
         }
-
-        private static RequestCulture DefaultGetRequestCulture(string defaultLanguage, IReadOnlyList<LanguageInfo> languages)
-        {
-            if (defaultLanguage == null)
-            {
-                var firstLanguage = languages.First();
-                return new RequestCulture(firstLanguage.CultureName, firstLanguage.UiCultureName);
-            }
-
-            var (cultureName, uiCultureName) = LocalizationSettingHelper.ParseLanguageSetting(defaultLanguage);
-            return new RequestCulture(cultureName, uiCultureName);
-        }
     }
 }

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/AbpRequestLocalizationMiddleware.cs

@@ -0,0 +1,26 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Localization;
+using Microsoft.Extensions.Options;
+using Volo.Abp.DependencyInjection;
+
+namespace Microsoft.AspNetCore.RequestLocalization
+{
+    public class AbpRequestLocalizationMiddleware : IMiddleware, ITransientDependency
+    {
+        private readonly IAbpRequestLocalizationOptionsProvider _requestLocalizationOptionsProvider;
+
+        public AbpRequestLocalizationMiddleware(
+            IAbpRequestLocalizationOptionsProvider requestLocalizationOptionsProvider)
+        {
+            _requestLocalizationOptionsProvider = requestLocalizationOptionsProvider;
+        }
+
+        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+        {
+            var options = Options.Create(_requestLocalizationOptionsProvider.GetLocalizationOptions());
+            var middleware = new RequestLocalizationMiddleware(next, options);
+            await middleware.Invoke(context);
+        }
+    }
+}

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/DefaultAbpRequestLocalizationOptionsProvider.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Localization;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Localization;
+using Volo.Abp.Settings;
+using Volo.Abp.Threading;
+
+namespace Microsoft.AspNetCore.RequestLocalization
+{
+    public class DefaultAbpRequestLocalizationOptionsProvider : IAbpRequestLocalizationOptionsProvider, ISingletonDependency
+    {
+        private readonly IServiceProvider _serviceProvider;
+        private Lazy<RequestLocalizationOptions> _lazyRequestLocalizationOptions;
+
+        public DefaultAbpRequestLocalizationOptionsProvider(IServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
+        public void InitLocalizationOptions(Action<RequestLocalizationOptions> optionsAction = null)
+        {
+            _lazyRequestLocalizationOptions = new Lazy<RequestLocalizationOptions>(() =>
+            {
+                using (var serviceScope = _serviceProvider.CreateScope())
+                {
+                    var languageProvider = serviceScope.ServiceProvider.GetRequiredService<ILanguageProvider>();
+                    var settingProvider = serviceScope.ServiceProvider.GetRequiredService<ISettingProvider>();
+
+                    var languages = AsyncHelper.RunSync(languageProvider.GetLanguagesAsync);
+                    var defaultLanguage = AsyncHelper.RunSync(() =>
+                        settingProvider.GetOrNullAsync(LocalizationSettingNames.DefaultLanguage));
+
+                    var options = !languages.Any()
+                        ? new RequestLocalizationOptions()
+                        : new RequestLocalizationOptions
+                        {
+                            DefaultRequestCulture = DefaultGetRequestCulture(defaultLanguage, languages),
+
+                            SupportedCultures = languages
+                                .Select(l => l.CultureName)
+                                .Distinct()
+                                .Select(c => new CultureInfo(c))
+                                .ToArray(),
+
+                            SupportedUICultures = languages
+                                .Select(l => l.UiCultureName)
+                                .Distinct()
+                                .Select(c => new CultureInfo(c))
+                                .ToArray()
+                        };
+
+                    optionsAction?.Invoke(options);
+                    return options;
+                }
+            }, true);
+        }
+
+        public RequestLocalizationOptions GetLocalizationOptions()
+        {
+            return _lazyRequestLocalizationOptions.Value;
+        }
+
+        private static RequestCulture DefaultGetRequestCulture(string defaultLanguage, IReadOnlyList<LanguageInfo> languages)
+        {
+            if (defaultLanguage == null)
+            {
+                var firstLanguage = languages.First();
+                return new RequestCulture(firstLanguage.CultureName, firstLanguage.UiCultureName);
+            }
+
+            var (cultureName, uiCultureName) = LocalizationSettingHelper.ParseLanguageSetting(defaultLanguage);
+            return new RequestCulture(cultureName, uiCultureName);
+        }
+    }
+}

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/IAbpRequestLocalizationOptionsProvider.cs

@@ -0,0 +1,12 @@
+using System;
+using Microsoft.AspNetCore.Builder;
+
+namespace Microsoft.AspNetCore.RequestLocalization
+{
+    public interface IAbpRequestLocalizationOptionsProvider
+    {
+        void InitLocalizationOptions(Action<RequestLocalizationOptions> optionsAction = null);
+
+        RequestLocalizationOptions GetLocalizationOptions();
+    }
+}

framework/src/Volo.Abp.Autofac/Volo.Abp.Autofac.csproj

@@ -15,7 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="Autofac.Extras.DynamicProxy" Version="4.5.0" />
-    <PackageReference Include="Autofac" Version="4.9.3" />
+    <PackageReference Include="Autofac" Version="4.9.4" />
   </ItemGroup>
 
   <ItemGroup>

framework/src/Volo.Abp.Caching/Volo/Abp/Caching/CacheOptions.cs

@@ -6,6 +6,11 @@ namespace Volo.Abp.Caching
 {
     public class CacheOptions
     {
+        /// <summary>
+        /// Cache key prefix.
+        /// </summary>
+        public string KeyPrefix { get; set; }
+
         /// <summary>
         /// Global Cache entry options.
         /// </summary>
@@ -21,6 +26,7 @@ namespace Volo.Abp.Caching
         {
             CacheConfigurators = new List<Func<string, DistributedCacheEntryOptions>>();
             GlobalCacheEntryOptions = new DistributedCacheEntryOptions();
+            KeyPrefix = "";
         }
     }
 }

framework/src/Volo.Abp.Caching/Volo/Abp/Caching/DistributedCache.cs

@@ -405,7 +405,7 @@ namespace Volo.Abp.Caching
 
         protected virtual string NormalizeKey(string key)
         {
-            var normalizedKey = "c:" + CacheName + ",k:" + key;
+            var normalizedKey = "c:" + CacheName + ",k:" + _cacheOption.KeyPrefix + key;
 
             if (!IgnoreMultiTenancy && CurrentTenant.Id.HasValue)
             {

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/DependencyInjection/AbpAspNetCoreMvcConventionalRegistrar_Tests.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Volo.Abp.DependencyInjection;
+using Xunit;
+
+namespace Volo.Abp.AspNetCore.Mvc.DependencyInjection
+{
+    public class AbpAspNetCoreMvcConventionalRegistrar_Tests
+    {
+        [Fact]
+        public void Should_Registered_Mvc_Service()
+        {
+            //Arrange
+            var services = new ServiceCollection();
+
+            //Act
+            services.AddConventionalRegistrar(new DefaultConventionalRegistrar());
+            services.AddConventionalRegistrar(new AbpAspNetCoreMvcConventionalRegistrar());
+
+            services.AddTypes(typeof(My_Test_PageModel), typeof(My_Test_Controller), typeof(My_Test_ViewComponent));
+
+            //Assert
+            services.ShouldContainTransient(typeof(My_Test_PageModel)); 
+            services.ShouldContainTransient(typeof(My_Test_Controller)); 
+            services.ShouldContainTransient(typeof(My_Test_ViewComponent)); 
+
+            var serviceProvider = services.BuildServiceProvider();
+            serviceProvider.GetServices<My_Test_PageModel>().Count().ShouldBe(1);
+            serviceProvider.GetServices<My_Test_Controller>().Count().ShouldBe(1);
+            serviceProvider.GetServices<My_Test_ViewComponent>().Count().ShouldBe(1);
+        }
+    }
+
+    public class My_Test_PageModel : PageModel
+    {
+
+    }
+
+    public class My_Test_Controller : Controller
+    {
+
+    }
+
+    public class My_Test_ViewComponent : ViewComponent
+    {
+
+    }
+}

modules/identity/src/Volo.Abp.Identity.Application/Volo/Abp/Identity/IdentityRoleAppService.cs

@@ -41,44 +41,54 @@ namespace Volo.Abp.Identity
         [Authorize(IdentityPermissions.Roles.Create)]
         public async Task<IdentityRoleDto> CreateAsync(IdentityRoleCreateDto input)
         {
-            var role = new IdentityRole(GuidGenerator.Create(), input.Name, CurrentTenant.Id);
+            using (_roleManager.AutoSaveRoleChanges(false))
+            {
+                var role = new IdentityRole(GuidGenerator.Create(), input.Name, CurrentTenant.Id);
 
-            role.IsDefault = input.IsDefault;
-            role.IsPublic = input.IsPublic;
+                role.IsDefault = input.IsDefault;
+                role.IsPublic = input.IsPublic;
 
-            (await _roleManager.CreateAsync(role)).CheckErrors();
-            await CurrentUnitOfWork.SaveChangesAsync();
+                (await _roleManager.CreateAsync(role)).CheckErrors();
+                await CurrentUnitOfWork.SaveChangesAsync();
 
-            return ObjectMapper.Map<IdentityRole, IdentityRoleDto>(role);
+                return ObjectMapper.Map<IdentityRole, IdentityRoleDto>(role);
+            }
         }
 
         [Authorize(IdentityPermissions.Roles.Update)]
         public async Task<IdentityRoleDto> UpdateAsync(Guid id, IdentityRoleUpdateDto input)
         {
-            var role = await _roleManager.GetByIdAsync(id);
-            role.ConcurrencyStamp = input.ConcurrencyStamp;
+            using (_roleManager.AutoSaveRoleChanges(false))
+            {
+                var role = await _roleManager.GetByIdAsync(id);
+                role.ConcurrencyStamp = input.ConcurrencyStamp;
 
-            (await _roleManager.SetRoleNameAsync(role, input.Name)).CheckErrors();
+                (await _roleManager.SetRoleNameAsync(role, input.Name)).CheckErrors();
 
-            role.IsDefault = input.IsDefault;
-            role.IsPublic = input.IsPublic;
+                role.IsDefault = input.IsDefault;
+                role.IsPublic = input.IsPublic;
 
-            (await _roleManager.UpdateAsync(role)).CheckErrors();
-            await CurrentUnitOfWork.SaveChangesAsync();
+                (await _roleManager.UpdateAsync(role)).CheckErrors();
+                await CurrentUnitOfWork.SaveChangesAsync();
 
-            return ObjectMapper.Map<IdentityRole, IdentityRoleDto>(role);
+                return ObjectMapper.Map<IdentityRole, IdentityRoleDto>(role);
+            }
         }
 
         [Authorize(IdentityPermissions.Roles.Delete)]
         public async Task DeleteAsync(Guid id)
         {
-            var role = await _roleManager.FindByIdAsync(id.ToString());
-            if (role == null)
+            using (_roleManager.AutoSaveRoleChanges(false))
             {
-                return;
+                var role = await _roleManager.FindByIdAsync(id.ToString());
+                if (role == null)
+                {
+                    return;
+                }
+
+                (await _roleManager.DeleteAsync(role)).CheckErrors();
+                await CurrentUnitOfWork.SaveChangesAsync();
             }
-
-            (await _roleManager.DeleteAsync(role)).CheckErrors();
         }
     }
 }

modules/identity/src/Volo.Abp.Identity.Application/Volo/Abp/Identity/IdentityUserAppService.cs

@@ -53,45 +53,55 @@ namespace Volo.Abp.Identity
         [Authorize(IdentityPermissions.Users.Create)]
         public async Task<IdentityUserDto> CreateAsync(IdentityUserCreateDto input)
         {
-            var user = new IdentityUser(GuidGenerator.Create(), input.UserName, input.Email, CurrentTenant.Id);
+            using (_userManager.AutoSaveUserChanges(false))
+            {
+                var user = new IdentityUser(GuidGenerator.Create(), input.UserName, input.Email, CurrentTenant.Id);
 
-            (await _userManager.CreateAsync(user, input.Password)).CheckErrors();
-            await UpdateUserByInput(user, input);
+                (await _userManager.CreateAsync(user, input.Password)).CheckErrors();
+                await UpdateUserByInput(user, input);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+                await CurrentUnitOfWork.SaveChangesAsync();
 
-            return ObjectMapper.Map<IdentityUser, IdentityUserDto>(user);
+                return ObjectMapper.Map<IdentityUser, IdentityUserDto>(user);
+            }
         }
 
         [Authorize(IdentityPermissions.Users.Update)]
         public async Task<IdentityUserDto> UpdateAsync(Guid id, IdentityUserUpdateDto input)
         {
-            var user = await _userManager.GetByIdAsync(id);
-            user.ConcurrencyStamp = input.ConcurrencyStamp;
+            using (_userManager.AutoSaveUserChanges(false))
+            {
+                var user = await _userManager.GetByIdAsync(id);
+                user.ConcurrencyStamp = input.ConcurrencyStamp;
 
-            (await _userManager.SetUserNameAsync(user, input.UserName)).CheckErrors();
-            await UpdateUserByInput(user, input);
-            (await _userManager.UpdateAsync(user)).CheckErrors();
-            await CurrentUnitOfWork.SaveChangesAsync();
+                (await _userManager.SetUserNameAsync(user, input.UserName)).CheckErrors();
+                await UpdateUserByInput(user, input);
+                (await _userManager.UpdateAsync(user)).CheckErrors();
+                await CurrentUnitOfWork.SaveChangesAsync();
 
-            return ObjectMapper.Map<IdentityUser, IdentityUserDto>(user);
+                return ObjectMapper.Map<IdentityUser, IdentityUserDto>(user);
+            }
         }
 
         [Authorize(IdentityPermissions.Users.Delete)]
         public async Task DeleteAsync(Guid id)
         {
-            if (CurrentUser.Id == id)
+            using (_userManager.AutoSaveUserChanges(false))
             {
-                throw new BusinessException(code: IdentityErrorCodes.UserSelfDeletion);
+                if (CurrentUser.Id == id)
+                {
+                    throw new BusinessException(code: IdentityErrorCodes.UserSelfDeletion);
+                }
+
+                var user = await _userManager.FindByIdAsync(id.ToString());
+                if (user == null)
+                {
+                    return;
+                }
+
+                (await _userManager.DeleteAsync(user)).CheckErrors();
+                await CurrentUnitOfWork.SaveChangesAsync();
             }
-
-            var user = await _userManager.FindByIdAsync(id.ToString());
-            if (user == null)
-            {
-                return;
-            }
-
-            (await _userManager.DeleteAsync(user)).CheckErrors();
         }
 
         [Authorize(IdentityPermissions.Users.Update)]

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IIdentityStoreAutoSaveChanges.cs

@@ -0,0 +1,7 @@
+namespace Volo.Abp.Identity
+{
+    public interface IIdentityStoreAutoSaveChanges
+    {
+        bool AutoSaveChanges { get; set; }
+    }
+}

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityRoleManager.cs

@@ -69,5 +69,20 @@ namespace Volo.Abp.Identity
 
             return await base.DeleteAsync(role);
         }
+
+        public IDisposable AutoSaveRoleChanges(bool autoSaveChanges)
+        {
+            if (!(Store is IIdentityStoreAutoSaveChanges store))
+            {
+                throw new InvalidOperationException(Store.GetType().FullName + " does not support AutoSaveChanges");
+            }
+
+            var currentAutoSaveChanges = store.AutoSaveChanges;
+            store.AutoSaveChanges = autoSaveChanges;
+            return new DisposeAction(() =>
+            {
+                store.AutoSaveChanges = currentAutoSaveChanges;
+            });
+        }
     }
 }

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityRoleStore.cs

@@ -20,6 +20,7 @@ namespace Volo.Abp.Identity
     public class IdentityRoleStore :
         IRoleStore<IdentityRole>,
         IRoleClaimStore<IdentityRole>,
+        IIdentityStoreAutoSaveChanges,
         ITransientDependency
     {
         private readonly IIdentityRoleRepository _roleRepository;

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityUserManager.cs

@@ -75,5 +75,20 @@ namespace Volo.Abp.Identity
 
             return IdentityResult.Success;
         }
+
+        public IDisposable AutoSaveUserChanges(bool autoSaveChanges)
+        {
+            if (!(Store is IIdentityStoreAutoSaveChanges store))
+            {
+                throw new InvalidOperationException(Store.GetType().FullName + " does not support AutoSaveChanges");
+            }
+
+            var currentAutoSaveChanges = store.AutoSaveChanges;
+            store.AutoSaveChanges = autoSaveChanges;
+            return new DisposeAction(() =>
+            {
+                store.AutoSaveChanges = currentAutoSaveChanges;
+            });
+        }
     }
 }

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityUserStore.cs

@@ -31,6 +31,7 @@ namespace Volo.Abp.Identity
         IUserAuthenticationTokenStore<IdentityUser>,
         IUserAuthenticatorKeyStore<IdentityUser>,
         IUserTwoFactorRecoveryCodeStore<IdentityUser>,
+        IIdentityStoreAutoSaveChanges,
         ITransientDependency
     {
         private const string InternalLoginProvider = "[AspNetUserStore]";

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.HttpApi.Host/MyProjectNameHttpApiHostModule.cs

@@ -15,6 +15,7 @@ using Volo.Abp;
 using Volo.Abp.AspNetCore.MultiTenancy;
 using Volo.Abp.AspNetCore.Mvc;
 using Volo.Abp.Autofac;
+using Volo.Abp.Caching;
 using Volo.Abp.Localization;
 using Volo.Abp.Modularity;
 using Volo.Abp.VirtualFileSystem;
@@ -41,11 +42,20 @@ namespace MyCompanyName.MyProjectName
             ConfigureAuthentication(context, configuration);
             ConfigureSwagger(context);
             ConfigureLocalization();
+            ConfigureCache(configuration);
             ConfigureVirtualFileSystem(context);
             ConfigureRedis(context, configuration, hostingEnvironment);
             ConfigureCors(context, configuration);
         }
 
+        private void ConfigureCache(IConfigurationRoot configuration)
+        {
+            Configure<CacheOptions>(options =>
+            {
+                options.KeyPrefix = "MyProjectName:";
+            });
+        }
+
         private void ConfigureVirtualFileSystem(ServiceConfigurationContext context)
         {
             var hostingEnvironment = context.Services.GetHostingEnvironment();

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.IdentityServer/MyProjectNameIdentityServerModule.cs

@@ -20,6 +20,7 @@ using Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared;
 using Volo.Abp.Auditing;
 using Volo.Abp.Autofac;
 using Volo.Abp.BackgroundJobs;
+using Volo.Abp.Caching;
 using Volo.Abp.Localization;
 using Volo.Abp.Modularity;
 using Volo.Abp.UI.Navigation.Urls;
@@ -91,6 +92,11 @@ namespace MyCompanyName.MyProjectName
                 options.IsJobExecutionEnabled = false;
             });
 
+            Configure<CacheOptions>(options =>
+            {
+                options.KeyPrefix = "MyProjectName:";
+            });
+
             context.Services.AddStackExchangeRedisCache(options =>
             {
                 options.Configuration = configuration["Redis:Configuration"];

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Web.Host/MyProjectNameWebModule.cs

@@ -22,6 +22,7 @@ using Volo.Abp.AspNetCore.Mvc.UI.Theme.Basic;
 using Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared;
 using Volo.Abp.Autofac;
 using Volo.Abp.AutoMapper;
+using Volo.Abp.Caching;
 using Volo.Abp.FeatureManagement;
 using Volo.Abp.Http.Client.IdentityModel;
 using Volo.Abp.Identity.Web;
@@ -68,6 +69,7 @@ namespace MyCompanyName.MyProjectName.Web
             var hostingEnvironment = context.Services.GetHostingEnvironment();
             var configuration = context.Services.GetConfiguration();
 
+            ConfigureCache(configuration);
             ConfigureUrls(configuration);
             ConfigureAuthentication(context, configuration);
             ConfigureAutoMapper();
@@ -77,6 +79,14 @@ namespace MyCompanyName.MyProjectName.Web
             ConfigureMultiTenancy();
         }
 
+        private void ConfigureCache(IConfigurationRoot configuration)
+        {
+            Configure<CacheOptions>(options =>
+            {
+                options.KeyPrefix = "MyProjectName:";
+            });
+        }
+
         private void ConfigureUrls(IConfigurationRoot configuration)
         {
             Configure<AppUrlOptions>(options =>

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.HttpApi.Host/MyProjectNameHttpApiHostModule.cs

@@ -11,6 +11,7 @@ using Volo.Abp;
 using Volo.Abp.AspNetCore.MultiTenancy;
 using Volo.Abp.AuditLogging.EntityFrameworkCore;
 using Volo.Abp.Autofac;
+using Volo.Abp.Caching;
 using Volo.Abp.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore.SqlServer;
 using Volo.Abp.Localization;
@@ -86,6 +87,11 @@ namespace MyCompanyName.MyProjectName
                     options.ApiName = "MyProjectName";
                 });
 
+            Configure<CacheOptions>(options =>
+            {
+                options.KeyPrefix = "MyProjectName:";
+            });
+
             context.Services.AddStackExchangeRedisCache(options =>
             {
                 options.Configuration = configuration["Redis:Configuration"];

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.IdentityServer/MyProjectNameIdentityServerModule.cs

@@ -14,6 +14,7 @@ using Volo.Abp.AspNetCore.Mvc.UI.Theme.Basic;
 using Volo.Abp.Auditing;
 using Volo.Abp.AuditLogging.EntityFrameworkCore;
 using Volo.Abp.Autofac;
+using Volo.Abp.Caching;
 using Volo.Abp.Data;
 using Volo.Abp.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore.SqlServer;
@@ -105,6 +106,11 @@ namespace MyCompanyName.MyProjectName
                     options.ApiName = configuration["AuthServer:ApiName"];
                 });
 
+            Configure<CacheOptions>(options =>
+            {
+                options.KeyPrefix = "MyProjectName:";
+            });
+
             context.Services.AddStackExchangeRedisCache(options =>
             {
                 options.Configuration = configuration["Redis:Configuration"];

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Host/MyProjectNameWebHostModule.cs

@@ -22,6 +22,7 @@ using Volo.Abp.AspNetCore.Mvc.UI.Theme.Basic;
 using Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared;
 using Volo.Abp.Autofac;
 using Volo.Abp.AutoMapper;
+using Volo.Abp.Caching;
 using Volo.Abp.Http.Client.IdentityModel;
 using Volo.Abp.Identity;
 using Volo.Abp.Identity.Web;
@@ -72,6 +73,7 @@ namespace MyCompanyName.MyProjectName
             var hostingEnvironment = context.Services.GetHostingEnvironment();
             var configuration = context.Services.GetConfiguration();
 
+            ConfigureCache(configuration);
             ConfigureUrls(configuration);
             ConfigureAuthentication(context, configuration);
             ConfigureAutoMapper();
@@ -80,6 +82,14 @@ namespace MyCompanyName.MyProjectName
             ConfigureMultiTenancy();
             ConfigureRedis(context, configuration, hostingEnvironment);
         }
+        
+        private void ConfigureCache(IConfigurationRoot configuration)
+        {
+            Configure<CacheOptions>(options =>
+            {
+                options.KeyPrefix = "MyProjectName:";
+            });
+        }
 
         private void ConfigureUrls(IConfigurationRoot configuration)
         {