Make ISettingProvider support batch get.

framework/src/Volo.Abp.AspNetCore.Mvc.Client.Common/Volo/Abp/AspNetCore/Mvc/Client/RemoteSettingProvider.cs

@@ -14,13 +14,19 @@ namespace Volo.Abp.AspNetCore.Mvc.Client
         {
             ConfigurationClient = configurationClient;
         }
-        
+
         public async Task<string> GetOrNullAsync(string name)
         {
             var configuration = await ConfigurationClient.GetAsync();
             return configuration.Setting.Values.GetOrDefault(name);
         }
 
+        public async Task<List<SettingValue>> GetAllAsync(string[] names)
+        {
+            var configuration = await ConfigurationClient.GetAsync();
+            return names.Select(x => new SettingValue(x, configuration.Setting.Values.GetOrDefault(x))).ToList();
+        }
+
         public async Task<List<SettingValue>> GetAllAsync()
         {
             var configuration = await ConfigurationClient.GetAsync();

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/ApplicationConfigurations/AbpApplicationConfigurationAppService.cs

@@ -251,14 +251,13 @@ namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations
                 Values = new Dictionary<string, string>()
             };
 
-            foreach (var settingDefinition in _settingDefinitionManager.GetAll())
-            {
-                if (!settingDefinition.IsVisibleToClients)
-                {
-                    continue;
-                }
+            var settingDefinitions = _settingDefinitionManager.GetAll().Where(x => x.IsVisibleToClients);
+
+            var settingValues = await _settingProvider.GetAllAsync(settingDefinitions.Select(x => x.Name).ToArray());
 
-                result.Values[settingDefinition.Name] = await _settingProvider.GetOrNullAsync(settingDefinition.Name);
+            foreach (var settingValue in settingValues)
+            {
+                result.Values[settingValue.Name] = settingValue.Value;
             }
 
             return result;

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/ConfigurationSettingValueProvider.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Volo.Abp.DependencyInjection;
 
@@ -23,5 +25,10 @@ namespace Volo.Abp.Settings
         {
             return Task.FromResult(Configuration[ConfigurationNamePrefix + setting.Name]);
         }
+
+        public Task<List<SettingValue>> GetAllAsync(SettingDefinition[] settings)
+        {
+            return Task.FromResult(settings.Select(x => new SettingValue(x.Name, Configuration[ConfigurationNamePrefix + x.Name])).ToList());
+        }
     }
-}
+}

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/DefaultValueSettingValueProvider.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 
 namespace Volo.Abp.Settings
 {
@@ -8,7 +10,7 @@ namespace Volo.Abp.Settings
 
         public override string Name => ProviderName;
 
-        public DefaultValueSettingValueProvider(ISettingStore settingStore) 
+        public DefaultValueSettingValueProvider(ISettingStore settingStore)
             : base(settingStore)
         {
 
@@ -18,5 +20,10 @@ namespace Volo.Abp.Settings
         {
             return Task.FromResult(setting.DefaultValue);
         }
+
+        public override Task<List<SettingValue>> GetAllAsync(SettingDefinition[] settings)
+        {
+            return Task.FromResult(settings.Select(x => new SettingValue(x.Name, x.DefaultValue)).ToList());
+        }
     }
-}
+}

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/GlobalSettingValueProvider.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 
 namespace Volo.Abp.Settings
 {
@@ -8,7 +10,7 @@ namespace Volo.Abp.Settings
 
         public override string Name => ProviderName;
 
-        public GlobalSettingValueProvider(ISettingStore settingStore) 
+        public GlobalSettingValueProvider(ISettingStore settingStore)
             : base(settingStore)
         {
         }
@@ -17,5 +19,10 @@ namespace Volo.Abp.Settings
         {
             return SettingStore.GetOrNullAsync(setting.Name, Name, null);
         }
+
+        public override Task<List<SettingValue>> GetAllAsync(SettingDefinition[] settings)
+        {
+            return SettingStore.GetAllAsync(settings.Select(x => x.Name).ToArray(), Name, null);
+        }
     }
-}
+}

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/ISettingProvider.cs

@@ -8,6 +8,8 @@ namespace Volo.Abp.Settings
     {
         Task<string> GetOrNullAsync([NotNull]string name);
 
+        Task<List<SettingValue>> GetAllAsync([NotNull]string[] names);
+
         Task<List<SettingValue>> GetAllAsync();
     }
 }

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/ISettingStore.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 
 namespace Volo.Abp.Settings
@@ -10,5 +11,11 @@ namespace Volo.Abp.Settings
             [CanBeNull] string providerName,
             [CanBeNull] string providerKey
         );
+
+        Task<List<SettingValue>> GetAllAsync(
+            [NotNull] string[] names,
+            [CanBeNull] string providerName,
+            [CanBeNull] string providerKey
+        );
     }
 }

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/ISettingValueProvider.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 
 namespace Volo.Abp.Settings
@@ -8,5 +9,7 @@ namespace Volo.Abp.Settings
         string Name { get; }
 
         Task<string> GetOrNullAsync([NotNull] SettingDefinition setting);
+
+        Task<List<SettingValue>> GetAllAsync([NotNull] SettingDefinition[] settings);
     }
-}
+}

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/NullSettingStore.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Volo.Abp.DependencyInjection;
@@ -19,5 +21,10 @@ namespace Volo.Abp.Settings
         {
             return Task.FromResult((string) null);
         }
+
+        public Task<List<SettingValue>> GetAllAsync(string[] names, string providerName, string providerKey)
+        {
+            return Task.FromResult(names.Select(x => new SettingValue(x, null)).ToList());
+        }
     }
-}
+}

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/SettingProvider.cs

@@ -43,29 +43,45 @@ namespace Volo.Abp.Settings
             return value;
         }
 
-        public virtual async Task<List<SettingValue>> GetAllAsync()
+        public async Task<List<SettingValue>> GetAllAsync(string[] names)
         {
-            var settingValues = new Dictionary<string, SettingValue>();
-            var settingDefinitions = SettingDefinitionManager.GetAll();
+            var result = new List<SettingValue>();
+            var settingDefinitions = SettingDefinitionManager.GetAll().Where(x => names.Contains(x.Name)).ToList();
 
-            foreach (var provider in SettingValueProviderManager.Providers)
+            foreach (var provider in Enumerable.Reverse(SettingValueProviderManager.Providers))
             {
-                foreach (var setting in settingDefinitions)
+                var settingValues = await provider.GetAllAsync(settingDefinitions.Where(x => !x.Providers.Any() || x.Providers.Contains(provider.Name)).ToArray());
+
+                var notNullValues = settingValues.Where(x => x.Value != null).ToList();
+                foreach (var settingValue in notNullValues)
                 {
-                    var value = await provider.GetOrNullAsync(setting);
-                    if (value != null)
+                    var value = settingValue;
+                    var settingDefinition = settingDefinitions.First(x => x.Name == value.Name);
+                    if (settingDefinition.IsEncrypted)
                     {
-                        if (setting.IsEncrypted)
-                        {
-                            value = SettingEncryptionService.Decrypt(setting, value);
-                        }
-
-                        settingValues[setting.Name] = new SettingValue(setting.Name, value);
+                        settingValue.Value = SettingEncryptionService.Decrypt(settingDefinition, settingValue.Value);
                     }
+
+                    result.Add(new SettingValue(settingValue.Name, settingValue.Value));
                 }
+
+                settingDefinitions.RemoveAll(x => notNullValues.Any(v => v.Name == x.Name));
+            }
+
+            return result;
+        }
+
+        public virtual async Task<List<SettingValue>> GetAllAsync()
+        {
+            var settingValues = new List<SettingValue>();
+            var settingDefinitions = SettingDefinitionManager.GetAll();
+
+            foreach (var setting in settingDefinitions)
+            {
+                settingValues.Add(new SettingValue(setting.Name, await GetOrNullAsync(setting.Name)));
             }
 
-            return settingValues.Values.ToList();
+            return settingValues;
         }
 
         protected virtual async Task<string> GetOrNullValueFromProvidersAsync(

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/SettingValueProvider.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
 
 namespace Volo.Abp.Settings
@@ -15,5 +16,7 @@ namespace Volo.Abp.Settings
         }
 
         public abstract Task<string> GetOrNullAsync(SettingDefinition setting);
+
+        public abstract Task<List<SettingValue>> GetAllAsync(SettingDefinition[] settings);
     }
-}
+}

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/TenantSettingValueProvider.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using Volo.Abp.MultiTenancy;
 
 namespace Volo.Abp.Settings
@@ -21,5 +23,10 @@ namespace Volo.Abp.Settings
         {
             return await SettingStore.GetOrNullAsync(setting.Name, Name, CurrentTenant.Id?.ToString());
         }
+
+        public async override Task<List<SettingValue>> GetAllAsync(SettingDefinition[] settings)
+        {
+            return await SettingStore.GetAllAsync(settings.Select(x => x.Name).ToArray(), Name, CurrentTenant.Id?.ToString());
+        }
     }
 }

framework/src/Volo.Abp.Settings/Volo/Abp/Settings/UserSettingValueProvider.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using Volo.Abp.Users;
 
 namespace Volo.Abp.Settings
@@ -26,5 +28,15 @@ namespace Volo.Abp.Settings
 
             return await SettingStore.GetOrNullAsync(setting.Name, Name, CurrentUser.Id.ToString());
         }
+
+        public async override Task<List<SettingValue>> GetAllAsync(SettingDefinition[] settings)
+        {
+            if (CurrentUser.Id == null)
+            {
+                return settings.Select(x => new SettingValue(x.Name, null)).ToList();
+            }
+
+            return await SettingStore.GetAllAsync(settings.Select(x => x.Name).ToArray(), Name, CurrentUser.Id.ToString());
+        }
     }
 }

framework/test/Volo.Abp.Settings.Tests/Volo/Abp/Settings/TestSettingValueProvider.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
 
@@ -12,7 +13,7 @@ namespace Volo.Abp.Settings
 
         public string Name => ProviderName;
 
-        public TestSettingValueProvider() 
+        public TestSettingValueProvider()
         {
             _values = new Dictionary<string, string>();
         }
@@ -21,5 +22,10 @@ namespace Volo.Abp.Settings
         {
             return Task.FromResult(_values.GetOrDefault(setting.Name));
         }
+
+        public Task<List<SettingValue>> GetAllAsync(SettingDefinition[] settings)
+        {
+            return Task.FromResult(settings.Select(x => new SettingValue(x.Name, _values.GetOrDefault(x.Name))).ToList());
+        }
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.Domain/Volo/Abp/PermissionManagement/PermissionStore.cs

@@ -118,7 +118,7 @@ namespace Volo.Abp.PermissionManagement
             var cacheItems = await GetCacheItemsAsync(names, providerName, providerKey);
             foreach (var item in cacheItems)
             {
-                result.Result.Add(PermissionGrantCacheItem.GetPermissionNameFormCacheKeyOrNull(item.Key),
+                result.Result.Add(GetPermissionNameFormCacheKeyOrNull(item.Key),
                     item.Value != null && item.Value.IsGranted
                         ? PermissionGrantResult.Granted
                         : PermissionGrantResult.Undefined);
@@ -202,5 +202,11 @@ namespace Volo.Abp.PermissionManagement
         {
             return PermissionGrantCacheItem.CalculateCacheKey(name, providerName, providerKey);
         }
+
+        protected virtual string GetPermissionNameFormCacheKeyOrNull(string key)
+        {
+            //TODO: throw ex when name is null?
+            return PermissionGrantCacheItem.GetPermissionNameFormCacheKeyOrNull(key);
+        }
     }
 }

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/ISettingManagementStore.cs

@@ -10,8 +10,10 @@ namespace Volo.Abp.SettingManagement
 
         Task<List<SettingValue>> GetListAsync(string providerName, string providerKey);
 
+        Task<List<SettingValue>> GetListAsync(string[] names, string providerName, string providerKey);
+
         Task SetAsync(string name, string value, string providerName, string providerKey);
-        
+
         Task DeleteAsync(string name, string providerName, string providerKey);
     }
-}
+}

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/SettingCacheItem.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Linq;
 using Volo.Abp.MultiTenancy;
+using Volo.Abp.Text.Formatting;
 
 namespace Volo.Abp.SettingManagement
 {
@@ -7,6 +9,8 @@ namespace Volo.Abp.SettingManagement
     [IgnoreMultiTenancy]
     public class SettingCacheItem
     {
+        private const string CacheKeyFormat = "pn:{0},pk:{1},n:{2}";
+
         public string Value { get; set; }
 
         public SettingCacheItem()
@@ -21,7 +25,13 @@ namespace Volo.Abp.SettingManagement
 
         public static string CalculateCacheKey(string name, string providerName, string providerKey)
         {
-            return "pn:" + providerName + ",pk:" + providerKey + ",n:" + name;
+            return string.Format(CacheKeyFormat, providerName, providerKey, name);
+        }
+
+        public static string GetSettingNameFormCacheKey(string cacheKey)
+        {
+            var result = FormattedStringValueExtracter.Extract(cacheKey, CacheKeyFormat, true);
+            return result.IsMatch ? result.Matches.Last().Value : cacheKey;
         }
     }
 }

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/SettingManagementStore.cs

@@ -118,9 +118,96 @@ namespace Volo.Abp.SettingManagement
             await Cache.SetManyAsync(cacheItems, considerUow: true);
         }
 
+        [UnitOfWork]
+        public async Task<List<SettingValue>> GetListAsync(string[] names, string providerName, string providerKey)
+        {
+            Check.NotNullOrEmpty(names, nameof(names));
+
+            var result = new List<SettingValue>();
+
+            if (names.Length == 1)
+            {
+                var name = names.First();
+                result.Add(new SettingValue(name, (await GetCacheItemAsync(name, providerName, providerKey)).Value));
+                return result;
+            }
+
+            var cacheItems = await GetCacheItemsAsync(names, providerName, providerKey);
+            foreach (var item in cacheItems)
+            {
+                result.Add(new SettingValue(GetSettingNameFormCacheKeyOrNull(item.Key), item.Value?.Value));
+            }
+
+            return result;
+        }
+
+        protected virtual async Task<List<KeyValuePair<string, SettingCacheItem>>> GetCacheItemsAsync(string[] names, string providerName, string providerKey)
+        {
+            var cacheKeys = names.Select(x => CalculateCacheKey(x, providerName, providerKey)).ToList();
+
+            var cacheItems = (await Cache.GetManyAsync(cacheKeys, considerUow: true)).ToList();
+
+            if (cacheItems.All(x => x.Value != null))
+            {
+                return cacheItems;
+            }
+
+            var notCacheKeys = cacheItems.Where(x => x.Value == null).Select(x => x.Key).ToList();
+
+            var newCacheItems = await SetCacheItemsAsync(providerName, providerKey, notCacheKeys);
+
+            var result = new List<KeyValuePair<string, SettingCacheItem>>();
+            foreach (var key in cacheKeys)
+            {
+                var item = newCacheItems.FirstOrDefault(x => x.Key == key);
+                if (item.Value == null)
+                {
+                    item = cacheItems.FirstOrDefault(x => x.Key == key);
+                }
+
+                result.Add(new KeyValuePair<string, SettingCacheItem>(key, item.Value));
+            }
+
+            return result;
+        }
+
+        private async Task<List<KeyValuePair<string, SettingCacheItem>>> SetCacheItemsAsync(
+            string providerName,
+            string providerKey,
+            IEnumerable<string> cacheKeys)
+        {
+            var settingDefinitions = SettingDefinitionManager.GetAll();
+            var settingsDictionary = (await SettingRepository.GetListAsync(providerName, providerKey))
+                .ToDictionary(s => s.Name, s => s.Value);
+
+            var cacheItems = new List<KeyValuePair<string, SettingCacheItem>>();
+
+            foreach (var settingDefinition in settingDefinitions)
+            {
+                var settingValue = settingsDictionary.GetOrDefault(settingDefinition.Name);
+                cacheItems.Add(
+                    new KeyValuePair<string, SettingCacheItem>(
+                        CalculateCacheKey(settingDefinition.Name, providerName, providerKey),
+                        new SettingCacheItem(settingValue)
+                    )
+                );
+            }
+
+            await Cache.SetManyAsync(cacheItems, considerUow: true);
+
+            return cacheItems.Where(x => cacheKeys.Contains(x.Key)).ToList();
+        }
+
+
         protected virtual string CalculateCacheKey(string name, string providerName, string providerKey)
         {
             return SettingCacheItem.CalculateCacheKey(name, providerName, providerKey);
         }
+
+        protected virtual string GetSettingNameFormCacheKeyOrNull(string key)
+        {
+            //TODO: throw ex when name is null?
+            return SettingCacheItem.GetSettingNameFormCacheKey(key);
+        }
     }
 }

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/SettingStore.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Settings;
 
@@ -17,5 +18,10 @@ namespace Volo.Abp.SettingManagement
         {
             return ManagementStore.GetOrNullAsync(name, providerName, providerKey);
         }
+
+        public virtual Task<List<SettingValue>> GetAllAsync(string[] names, string providerName, string providerKey)
+        {
+            return ManagementStore.GetListAsync(names, providerName, providerKey);
+        }
     }
 }

modules/setting-management/test/Volo.Abp.SettingManagement.Tests/Volo/Abp/SettingManagement/SettingManagementStore_Tests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Shouldly;
@@ -94,5 +95,26 @@ namespace Volo.Abp.SettingManagement
             }
         }
 
+        [Fact]
+        public async Task GetListAsync()
+        {
+            var result = await _settingManagementStore.GetListAsync(
+                new[]
+                {
+                    "MySetting1",
+                    "MySetting2",
+                    "MySetting3",
+                    "notExistName"
+                },
+                GlobalSettingValueProvider.ProviderName,
+                null);
+
+            result.Count.ShouldBe(4);
+
+            result.First(x => x.Name == "MySetting1").Value.ShouldBe("42");
+            result.First(x => x.Name == "MySetting2").Value.ShouldBe("default-store-value");
+            result.First(x => x.Name == "MySetting3").Value.ShouldBe(null);
+            result.First(x => x.Name == "notExistName").Value.ShouldBe(null);
+        }
     }
 }