osharp multi-tenant solution
Tenant information
using System;
using;
using;
using;
using;
namespace
{
/// <summary>
/// Tenant information
/// </summary>
public class TenantInfo
{
/// <summary>
/// Get or set the tenant ID
/// </summary>
public string TenantId { get; set; }
/// <summary>
/// Get or set the tenant name
/// </summary>
public string Name { get; set; }
/// <summary>
/// Get or set the tenant host
/// </summary>
public string Host { get; set; }
/// <summary>
/// Get or set the connection string
/// </summary>
public string ConnectionString { get; set; }
/// <summary>
/// Get or set whether to enable
/// </summary>
public bool IsEnabled { get; set; } = true;
}
}Define tenant accessor implementation
using System;
using;
using;
using;
using;
namespace
{
// Tenant accessor implementation
public class TenantAccessor : ITenantAccessor
{
public TenantInfo CurrentTenant { get; set; }
}
/// <summary>
/// Tenant information accessor implemented using AsyncLocal<T>
/// </summary>
public class AsyncLocalTenantAccessor: ITenantAccessor
{
// Use AsyncLocal<T> to store tenant information
private static readonly AsyncLocal<TenantInfo> _currentTenant = new AsyncLocal<TenantInfo>();
/// <summary>
/// Get or set the current tenant
/// </summary>
public TenantInfo CurrentTenant
{
get => _currentTenant.Value;
set => _currentTenant.Value = value;
}
}
}Modify MultiTenantConnectionStringProvider to use the database connection of the selected tenant
using;
using;
using;
using;
using System;
using;
using;
using;
using;
using;
namespace
{
/// <summary>
/// Tenant database selector, implement IConnectionStringProvider interface
/// </summary>
public class MultiTenantConnectionStringProvider: IConnectionStringProvider
{
private readonly IConfiguration _configuration;
private readonly ITenantAccessor _tenantAccessor;
private readonly ILogger<MultiTenantConnectionStringProvider> _logger;
private readonly ConcurrentDictionary<string, string> _connectionStringCache = new ConcurrentDictionary<string, string>();
public MultiTenantConnectionStringProvider(
IConfiguration configuration,
ITenantAccessor tenantAccessor,
ILogger<MultiTenantConnectionStringProvider> logger)
{
_configuration = configuration;
_tenantAccessor = tenantAccessor;
_logger = logger;
}
/// <summary>
/// Get the database connection string
/// </summary>
public string GetConnectionString(Type dbContextType)
{
if( == "TenantDbContext")
{
return _configuration.GetConnectionString("Tenant");
}
// Get the current tenant
TenantInfo tenant = _tenantAccessor.CurrentTenant;
// Get the connection string name of DbContext
string connectionStringName = ("DbContext", "");
// Build cache keys
string cacheKey = tenant?.TenantId + "_" + connectionStringName;
// Try to get the connection string from the cache
if (!(cacheKey) && _connectionStringCache.TryGetValue(cacheKey, out string cachedConnectionString))
{
return cachedConnectionString;
}
string connectionString = null;
// If there is tenant information
if (tenant != null)
{
// 1. First try using the tenant's own connection string
if (!())
{
connectionString = ;
_logger.LogDebug("Use the connection string of tenant {TenantId}", );
}
else
{
// 2. Try to get specific DbContext connection string for specific tenants from configuration
string tenantConnectionStringKey = $"ConnectionStrings:{}:{connectionStringName}";
connectionString = _configuration[tenantConnectionStringKey];
// 3. Try to get the default connection string for a specific tenant from the configuration
if ((connectionString))
{
string tenantDefaultConnectionStringKey = $"ConnectionStrings:{}:Default";
connectionString = _configuration[tenantDefaultConnectionStringKey];
if (!(connectionString))
{
_logger.LogDebug("Use the default connection string for tenant {TenantId}", );
}
}
else
{
_logger.LogDebug("Use the {DbContext} connection string of tenant {TenantId}", , connectionStringName);
}
}
}
// 4. If the connection string is still not found, use the application's default connection string
if ((connectionString))
{
// Try to get the connection string for a specific DbContext
connectionString = _configuration.GetConnectionString(connectionStringName);
// If there is no connection string for a specific DbContext, use the default connection string
if ((connectionString))
{
connectionString = _configuration.GetConnectionString("Default");
_logger.LogDebug("Use the application default connection string");
}
else
{
_logger.LogDebug("Connect string using application {DbContext}", connectionStringName);
}
}
// Cache connection string
if (!(cacheKey) && !(connectionString))
{
_connectionStringCache[cacheKey] = connectionString;
}
return connectionString;
}
}
}Revise
// -----------------------------------------------------------------------
// <copyright file="" company="OSharp open source team">
// Copyright (c) 2014-2018 OSharp. All rights reserved.
// </copyright>
// <site></site>
// <last-editor>Guo Mingfeng</last-editor>
// <last-date>2018-06-27 4:50</last-date>
// -----------------------------------------------------------------------
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using OSharp.Log4Net;
using;
using;
using;
using;
using;
using;
using;
var builder = (args);
<FileTenantStoreOptions>(options =>
{
= "App_Data/";
});
// Add a service to the container
// Register tenant accessor
<ITenantAccessor, AsyncLocalTenantAccessor>();
<ITenantProvider, HttpTenantProvider>();
// Registered tenant storage
//<ITenantStore, ConfigurationTenantStore>();
//<ITenantStore, FileTenantStore>();
<ITenantStore, DatabaseTenantStore>();
(); // Register IHttpContextAccessor
// Register a tenant database migrator
<TenantDatabaseMigrator>();
// Replace the default connection string provider
//<IConnectionStringProvider, MultiTenantConnectionStringProvider>();
<IConnectionStringProvider, MultiTenantConnectionStringProvider>();
<ICacheKeyGenerator, StringCacheKeyGenerator>();
<IGlobalCacheKeyGenerator>(provider =>
<ICacheKeyGenerator>() as IGlobalCacheKeyGenerator);
//();
()
.AddPack<Log4NetPack>()
.AddPack<AutoMapperPack>()
.AddPack<EndpointsPack>()
.AddPack<MiniProfilerPack>()
.AddPack<SwaggerPack>()
//.AddPack<RedisPack>()
.AddPack<AuthenticationPack>()
.AddPack<FunctionAuthorizationPack>()
.AddPack<DataAuthorizationPack>()
.AddPack<SqlServerDefaultDbContextMigrationPack>()
.AddPack<TenantDbContextMigrationPack>()
.AddPack<AuditPack>()
.AddPack<InfosPack>();
var app = ();
// Register in the request pipeline TenantMiddleware
// Note: It should be registered after UseRouting, but before UseAuthentication and UseAuthorization
();
// Add multi-tenant middleware
<TenantMiddleware>();
// Use OSharp
();
using (var scope = ())
{
var migrator = <TenantDatabaseMigrator>();
await ();
}
();Change HasName in all database configuration files to HasDatabaseName
Set the project to .net8.0
Tenant storage management
//ITenantStore
using System;
using;
using;
using;
using;
namespace
{
/// <summary>
/// Define tenant storage
/// </summary>
public interface ITenantStore
{
/// <summary>
/// Get all tenants
/// </summary>
Task<IEnumerable<TenantInfo>> GetAllTenantsAsync();
/// <summary>
/// Obtain tenant according to tenant ID
/// </summary>
Task<TenantInfo> GetTenantAsync(string tenantId);
/// <summary>
/// Get tenant based on hostname
/// </summary>
Task<TenantInfo> GetTenantByHostAsync(string host);
/// <summary>
/// Save tenant information
/// </summary>
Task<bool> SaveTenantAsync(TenantInfo tenant);
/// <summary>
/// Delete tenant
/// </summary>
Task<bool> DeleteTenantAsync(string tenantId);
}
}//FileTenantStore
using;
using;
using System;
using;
using;
using;
using;
using;
using;
namespace
{
/// <summary>
/// File-based tenant storage implementation, save tenant information in JSON file
/// </summary>
public class FileTenantStore: ITenantStore
{
private readonly FileTenantStoreOptions _options;
private readonly ILogger<FileTenantStore> _logger;
private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
private Dictionary<string, TenantInfo> _tenants = new Dictionary<string, TenantInfo>();
private bool _isInitialized = false;
public FileTenantStore(
IOptions<FileTenantStoreOptions> options,
ILogger<FileTenantStore> logger)
{
_options = ;
_logger = logger;
}
/// <summary>
/// Get all enabled tenants
/// </summary>
public async Task<IEnumerable<TenantInfo>> GetAllTenantsAsync()
{
await EnsureInitializedAsync();
return _tenants.(t => ).ToList();
}
/// <summary>
/// Obtain tenant information based on tenant ID
/// </summary>
public async Task<TenantInfo> GetTenantAsync(string tenantId)
{
if ((tenantId))
{
return null;
}
await EnsureInitializedAsync();
if (_tenants.TryGetValue(tenantId, out var tenant) && )
{
return tenant;
}
return null;
}
/// <summary>
/// Get tenant information based on host name
/// </summary>
public async Task<TenantInfo> GetTenantByHostAsync(string host)
{
if ((host))
{
return null;
}
await EnsureInitializedAsync();
return _tenants.Values
.FirstOrDefault(t => &&
((host, ) ||
("." + , )));
}
/// <summary>
/// Save tenant information
/// </summary>
public async Task<bool> SaveTenantAsync(TenantInfo tenant)
{
if (tenant == null || ())
{
return false;
}
await EnsureInitializedAsync();
await _semaphore.WaitAsync();
try
{
// Update tenant information in memory
_tenants[] = tenant;
// Save to file
await SaveToFileAsync();
_logger.LogInformation("Save tenant information: {TenantId}, {Name}, {Host}",
, , );
return true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Save tenant information failed: {TenantId}", );
return false;
}
Finally
{
_semaphore.Release();
}
}
/// <summary>
/// Delete tenant information
/// </summary>
public async Task<bool> DeleteTenantAsync(string tenantId)
{
if ((tenantId))
{
return false;
}
await EnsureInitializedAsync();
await _semaphore.WaitAsync();
try
{
if (!_tenants.ContainsKey(tenantId))
{
return false;
}
// Remove tenant from memory
_tenants.Remove(tenantId);
// Save to file
await SaveToFileAsync();
_logger.LogInformation("Deleted tenant: {TenantId}", tenantId);
return true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Delete failed: {TenantId}", tenantId);
return false;
}
Finally
{
_semaphore.Release();
}
}
/// <summary>
/// Make sure it has been initialized
/// </summary>
private async Task EnsureInitializedAsync()
{
if (_isInitialized)
{
return;
}
await _semaphore.WaitAsync();
try
{
if (_isInitialized)
{
return;
}
await LoadFromFileAsync();
_isInitialized = true;
}
Finally
{
_semaphore.Release();
}
}
/// <summary>
/// Load tenant information from the file
/// </summary>
private async Task LoadFromFileAsync()
{
string filePath = GetFilePath();
if (!(filePath))
{
_logger.LogInformation("The tenant configuration file does not exist, a new file will be created: {FilePath}", filePath);
_tenants = new Dictionary<string, TenantInfo>();
await SaveToFileAsync(); // Create an empty file
return;
}
try
{
string json = await (filePath);
var tenants = <List<TenantInfo>>(json, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
_tenants = (t => );
_logger.LogInformation("{Count} tenants loaded from file", _tenants.Count);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to load tenant information from file: {FilePath}", filePath);
_tenants = new Dictionary<string, TenantInfo>();
}
}
/// <summary>
/// Save tenant information to file
/// </summary>
private async Task SaveToFileAsync()
{
string filePath = GetFilePath();
string directoryPath = (filePath);
if (!(directoryPath))
{
(directoryPath);
}
try
{
var tenants = _tenants.();
string json = (tenants, new JsonSerializerOptions
{
WriteIndented = true
});
await (filePath, json);
_logger.LogDebug("The {Count} tenant information has been saved to a file: {FilePath}", , filePath);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to save tenant information to file: {FilePath}", filePath);
throw;
}
}
/// <summary>
/// Get the file path
/// </summary>
private string GetFilePath()
{
return (_options.FilePath);
}
}
/// <summary>
/// File tenant storage options
/// </summary>
public class FileTenantStoreOptions
{
/// <summary>
/// The path of the tenant configuration file, default to "App_Data/"
/// </summary>
public string FilePath { get; set; } = "App_Data/";
}
}//ConfigurationTenantStore
using;
using;
using System;
using;
using;
using;
using;
namespace
{
/// <summary>
/// Tenant storage implementation based on configuration file
/// </summary>
public class ConfigurationTenantStore: ITenantStore
{
private readonly IConfiguration _configuration;
private readonly ILogger<ConfigurationTenantStore> _logger;
private readonly Dictionary<string, TenantInfo> _tenants = new Dictionary<string, TenantInfo>();
public ConfigurationTenantStore(
IConfiguration configuration,
ILogger<ConfigurationTenantStore> logger)
{
_configuration = configuration;
_logger = logger;
// Load tenant information from the configuration
LoadTenantsFromConfiguration();
}
public Task<bool> DeleteTenantAsync(string tenantId)
{
throw new NotImplementedException();
}
public Task<IEnumerable<TenantInfo>> GetAllTenantsAsync()
{
return (_tenants.(t => ).AsEnumerable());
}
public Task<TenantInfo> GetTenantAsync(string tenantId)
{
if ((tenantId) || !_tenants.TryGetValue(tenantId, out var tenant) || !)
{
return <TenantInfo>(null);
}
return (tenant);
}
public Task<TenantInfo> GetTenantByHostAsync(string host)
{
if ((host))
{
return <TenantInfo>(null);
}
var tenant = _tenants.Values
.FirstOrDefault(t => &&
((host, ) ||
("." + , )));
return (tenant);
}
public Task<bool> SaveTenantAsync(TenantInfo tenant)
{
// Configuration file implementation is usually read-only and does not support saving
_logger.LogWarning("ConfigurationTenantStore does not support saving tenant information");
return (false);
}
private void LoadTenantsFromConfiguration()
{
var tenantsSection = _configuration.GetSection("Tenants");
if (!())
{
_logger.LogWarning("No 'Tenants' node found in configuration");
return;
}
foreach (var tenantSection in ())
{
var tenant = new TenantInfo
{
TenantId = ,
Name = tenantSection["Name"],
Host = tenantSection["Host"],
ConnectionString = tenantSection["ConnectionString"],
IsEnabled = <bool>("IsEnabled", true)
};
if (!() && !())
{
_tenants[] = tenant;
_logger.LogInformation("Loaded tenant: {TenantId}, {Name}, {Host}", , , );
}
else
{
_logger.LogWarning("Tenant configuration is incomplete, skipped: {TenantId}", );
}
}
}
}
}Database-based tenant storage implementation
using;
using;
using;
using;
using;
using;
using System;
using;
using;
using;
using;
namespace
{
/// <summary>
/// Database-based tenant storage implementation
/// </summary>
public class DatabaseTenantStore: ITenantStore
{
private readonly IServiceProvider _serviceProvider;
private readonly IMemoryCache _cache;
private readonly ILogger<DatabaseTenantStore> _logger;
private readonly TimeSpan _cacheExpiration = (10);
private const string CacheKeyPrefix = "Tenant_";
private const string AllTenantsCacheKey = "AllTenants";
private readonly IConfiguration _configuration;
public DatabaseTenantStore(
IServiceProvider serviceProvider,
IMemoryCache cache,
IConfiguration configuration,
ILogger<DatabaseTenantStore> logger)
{
_serviceProvider = serviceProvider;
_cache = cache;
_logger = logger;
_configuration = configuration;
}
/// <summary>
/// Get all enabled tenants
/// </summary>
public async Task<IEnumerable<TenantInfo>> GetAllTenantsAsync()
{
// Try to get from cache
if (_cache.TryGetValue(AllTenantsCacheKey, out IEnumerable<TenantInfo> cachedTenants))
{
return cachedTenants;
}
// Get from the database
using var scope = _serviceProvider.CreateScope();
var TenantRepository = <IRepository<TenantEntity,Guid>>();
var tenantEntities = await().Where(t => ).ToListAsync();
if( == 0)
{
await ImportFromConfigurationAsync(_configuration);
}
tenantEntities = await().Where(t => ).ToListAsync();
var tenants = (MapToTenantInfo).ToList();
// Cache results
_cache.Set(AllTenantsCacheKey, tenants, _cacheExpiration);
return tenants;
}
/// <summary>
/// Obtain tenant according to tenant ID
/// </summary>
public async Task<TenantInfo> GetTenantAsync(string tenantId)
{
if ((tenantId))
{
return null;
}
// Try to get from cache
string cacheKey = $"{CacheKeyPrefix}{tenantId}";
if (_cache.TryGetValue(cacheKey, out TenantInfo cachedTenant))
{
return cachedTenant;
}
// Get from the database
using var scope = _serviceProvider.CreateScope();
var TenantRepository = <IRepository<TenantEntity, Guid>>();
var tenantEntity = await().Where(t => == tenantId).FirstOrDefaultAsync();
if (tenantEntity == null)
{
return null;
}
var tenant = MapToTenantInfo(tenantEntity);
// Cache results
_cache.Set(cacheKey, tenant, _cacheExpiration);
return tenant;
}
/// <summary>
/// Get tenant based on hostname
/// </summary>
public async Task<TenantInfo> GetTenantByHostAsync(string host)
{
if ((host))
{
return null;
}
// Get all tenants
var allTenants = await GetAllTenantsAsync();
// Find matching tenants
return (t =>
(host, ) ||
(".” + , ));
}
/// <summary>
/// Save tenant information
/// </summary>
public async Task<bool> SaveTenantAsync(TenantInfo tenant)
{
if (tenant == null || ())
{
return false;
}
using var scope = _serviceProvider.CreateScope();
var TenantRepository = <IRepository<TenantEntity, Guid>>();
var existingEntity = await().Where(t => == ).FirstOrDefaultAsync();
try
{
if (existingEntity == null)
{
// Create a new tenant
var newEntity = new TenantEntity
{
TenantId = ,
Name = ,
Host = ,
ConnectionString = ,
IsEnabled = ,
CreatedTime =
};
await (newEntity);
_logger.LogInformation("Create a new tenant: {TenantId}, {Name}", , );
}
else
{
// Update existing tenants
= ;
= ;
= ;
= ;
= ;
await (existingEntity);
_logger.LogInformation("Update tenant: {TenantId}, {Name}", , );
}
// Clear cache
InvalidateCache();
return true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Save tenant information failed: {TenantId}", );
return false;
}
}
/// <summary>
/// Delete tenant
/// </summary>
public async Task<bool> DeleteTenantAsync(string tenantId)
{
if ((tenantId))
{
return false;
}
using var scope = _serviceProvider.CreateScope();
var TenantRepository = <IRepository<TenantEntity, Guid>>();
var tenantEntity = await().Where(t => == tenantId).FirstOrDefaultAsync();
if (tenantEntity == null)
{
return false;
}
try
{
await (tenantEntity);
// Clear cache
InvalidateCache(tenantId);
_logger.LogInformation("Delete tenant: {TenantId}", tenantId);
return true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Delete failed: {TenantId}", tenantId);
return false;
}
}
/// <summary>
/// Import tenant information from configuration to database
/// </summary>
public async Task<int> ImportFromConfigurationAsync(IConfiguration configuration)
{
var tenantsSection = ("Tenants");
if (!())
{
_logger.LogWarning("No 'Tenants' node found in configuration");
return 0;
}
int importCount = 0;
foreach (var tenantSection in ())
{
var tenant = new TenantInfo
{
TenantId = ,
Name = tenantSection["Name"],
Host = tenantSection["Host"],
ConnectionString = tenantSection["ConnectionString"],
IsEnabled = <bool>("IsEnabled", true)
};
// If ConnectionString is empty, try to get it from the ConnectionStrings node
if (())
{
string connectionStringKey = $"ConnectionStrings:{}:Default";
= configuration[connectionStringKey];
// If it is still empty, try to directly get the connection string corresponding to the tenant ID
if (())
{
= ();
}
}
if (!() && !())
{
bool success = await SaveTenantAsync(tenant);
if (success)
{
importCount++;
_logger.LogInformation("Imported tenant: {TenantId}, {Name}, {Host}",
, , );
}
}
else
{
_logger.LogWarning("Tenant configuration is incomplete, skipped: {TenantId}", );
}
}
// Clear all caches
_cache.Remove(AllTenantsCacheKey);
return importCount;
}
/// <summary>
/// Map entities to tenant information
/// </summary>
private TenantInfo MapToTenantInfo(TenantEntity entity)
{
return new TenantInfo
{
TenantId = ,
Name = ,
Host = ,
ConnectionString = ,
IsEnabled =
};
}
/// <summary>
/// Invalidate the cache
/// </summary>
private void InvalidateCache(string tenantId)
{
_cache.Remove($"{CacheKeyPrefix}{tenantId}");
_cache.Remove(AllTenantsCacheKey);
}
}
}TenantEntity
using System;
using;
using;
using;
namespace
{
/// <summary>
/// Tenant database entity
/// </summary>
[Description("Tenant Information")]
public class TenantEntity : EntityBase<Guid>
{
/// <summary>
/// Get or set the tenant ID
/// </summary>
[Required, StringLength(50)]
[Description("Tenant ID")]
public string TenantId { get; set; }
/// <summary>
/// Get or set the tenant name
/// </summary>
[Required, StringLength(100)]
[Description("Tenant Name")]
public string Name { get; set; }
/// <summary>
/// Get or set the tenant host
/// </summary>
[Required, StringLength(100)]
[Description("Tenant Host")]
public string Host { get; set; }
/// <summary>
/// Get or set the connection string
/// </summary>
[StringLength(1000)]
[Description("Connection String")]
public string ConnectionString { get; set; }
/// <summary>
/// Get or set whether to enable
/// </summary>
[Description("Enabled")]
public bool IsEnabled { get; set; } = true;
/// <summary>
/// Get or set the creation time
/// </summary>
[Description("Create Time")]
public DateTime CreatedTime { get; set; } = ;
/// <summary>
/// Get or set update time
/// </summary>
[Description("Update Time")]
public DateTime? UpdatedTime { get; set; }
}
}TenantDbContext
using;
using;
namespace
{
/// <summary>
/// Tenant database context
/// </summary>
public class TenantDbContext: DbContextBase
{
/// <summary>
/// Initialize a new instance of type <see cref="TenantDbContext"/>
/// </summary>
public TenantDbContext(DbContextOptions<TenantDbContext> options, IServiceProvider serviceProvider)
: base(options, serviceProvider)
{
}
}
}//TenantEntityConfiguration
using;
using;
using;
using;
using System;
namespace
{
/// <summary>
/// Tenant entity type configuration
/// </summary>
public partial class TenantEntityConfiguration : EntityTypeConfigurationBase<TenantEntity, Guid>
{
public override Type DbContextType { get; } = typeof(TenantDbContext);
/// <summary>
/// Rewrite to implement database configuration for each attribute of entity type
/// </summary>
/// <param name="builder">Entity Type Builder</param>
public override void Configure(EntityTypeBuilder<TenantEntity> builder)
{
//Configuration table name
("Tenants");
//Configuration properties
(m => )
.IsRequired()
.HasMaxLength(50)
.HasComment("Tenant ID");
(m => )
.IsRequired()
.HasMaxLength(100)
.HasComment("Tenant Name");
(m => )
.IsRequired()
.HasMaxLength(100)
.HasComment("Tenant Host");
(m => )
.HasMaxLength(1000)
.HasComment("Connection String");
(m => )
.IsRequired()
.HasDefaultValue(true)
.HasComment("Enabled");
(m => )
.IsRequired()
.HasComment("Create Time");
(m => )
.HasComment("Update Time");
// Configure index
(m => )
.IsUnique()
.HasDatabaseName("IX_Tenants_TenantId");
(m => )
.HasDatabaseName("IX_Tenants_Host");
EntityConfigurationAppend(builder);
}
/// <summary>
/// Additional data mapping
/// </summary>
partial void EntityConfigurationAppend(EntityTypeBuilder<TenantEntity> builder);
}
}Define tenant providers
using System;
using;
using;
using;
using;
namespace
{
/// <summary>
/// Define tenant provider
/// </summary>
public interface ITenantProvider
{
/// <summary>
/// Get current tenant information
/// </summary>
/// <returns>Tenant information</returns>
TenantInfo GetCurrentTenant();
/// <summary>
/// Asynchronously obtain current tenant information
/// </summary>
/// <returns>Tenant information</returns>
Task<TenantInfo> GetCurrentTenantAsync();
/// <summary>
/// Obtain tenant information based on tenant identity
/// </summary>
/// <param name="identifier">tenant ID</param>
/// <returns>Tenant information</returns>
TenantInfo GetTenant(string identifier);
/// <summary>
/// Asynchronously obtain tenant information based on tenant identity
/// </summary>
/// <param name="identifier">tenant ID</param>
/// <returns>Tenant information</returns>
Task<TenantInfo> GetTenantAsync(string identifier);
}
}//HttpTenantProvider
using;
using;
using System;
using;
using;
using;
using;
using;
using;
using;
namespace
{
/// <summary>
/// Tenant provider implementation based on HTTP requests supports multiple ways to identify tenants
/// </summary>
public class HttpTenantProvider: ITenantProvider
{
private readonly IHttpContextAccessor _httpContextAccessor;
private readonly IConfiguration _configuration;
private readonly ILogger<HttpTenantProvider> _logger;
private readonly ITenantAccessor _tenantAccessor; // Add tenant accessor
private readonly ITenantStore _tenantStore; // Use ITenantStore
// Tenant identification method configuration
private readonly TenantResolveOptions _resolveOptions;
public HttpTenantProvider(
IHttpContextAccessor httpContextAccessor,
IConfiguration configuration,
ILogger<HttpTenantProvider> logger,
ITenantStore tenantStore,
ITenantAccessor tenantAccessor)
{
_httpContextAccessor = httpContextAccessor;
_configuration = configuration;
_logger = logger;
_tenantAccessor = tenantAccessor;
_tenantStore = tenantStore;
// Initialize the tenant identification method configuration
_resolveOptions = new TenantResolveOptions();
ConfigureTenantResolveOptions();
}
/// <summary>
/// Get current tenant information
/// </summary>
public async Task<TenantInfo> GetCurrentTenantAsync()
{
// First check whether there is tenant information in the tenant accessor
if (_tenantAccessor.CurrentTenant != null)
{
return _tenantAccessor.CurrentTenant;
}
HttpContext httpContext = _httpContextAccessor.HttpContext;
if (httpContext == null)
{
return null;
}
// Try to identify tenants in multiple ways
TenantInfo tenant = null;
// Try different tenant identification methods in order of priority
foreach (var resolver in _resolveOptions.(r => ))
{
tenant = await (httpContext, _tenantStore);
if (tenant != null)
{
// Set the resolved tenant into the tenant accessor
_tenantAccessor.CurrentTenant = tenant;
return tenant;
}
}
return tenant;
}
/// <summary>
/// Obtain tenant information based on tenant identity
/// </summary>
public TenantInfo GetTenant(string identifier)
{
if ((identifier))
{
return null;
}
return GetTenantAsync(identifier).GetAwaiter().GetResult();
}
/// <summary>
/// Asynchronously obtain tenant information based on tenant identity
/// </summary>
public async Task<TenantInfo> GetTenantAsync(string identifier)
{
if ((identifier))
{
return null;
}
TenantInfo tenant = await _tenantStore.GetTenantAsync(identifier);
return tenant?.IsEnabled == true ? tenant : null;
}
/// <summary>
/// Configure tenant identification method
/// </summary>
private void ConfigureTenantResolveOptions()
{
// Read tenant identification method configuration from configuration
var resolveSection = _configuration.GetSection("MultiTenancy:TenantResolve");
// Add a domain name resolver (enabled by default, with the highest priority)
bool enableDomain = <bool>("EnableDomain", true);
if (enableDomain)
{
_resolveOptions.AddResolver(new DomainTenantResolver(), 100);
}
// Add a request header parser
bool enableHeader = <bool>("EnableHeader", false);
string headerName = <string>("HeaderName", "X-Tenant");
if (enableHeader)
{
_resolveOptions.AddResolver(new HeaderTenantResolver(headerName), 200);
}
// Add query parameter parser
bool enableQueryString = <bool>("EnableQueryString", false);
string queryStringName = <string>("QueryStringName", "tenant");
if (enableQueryString)
{
_resolveOptions.AddResolver(new QueryStringTenantResolver(queryStringName), 300);
}
// Add a cookie parser
bool enableCookie = <bool>("EnableCookie", false);
string cookieName = <string>("CookieName", "tenant");
if (enableCookie)
{
_resolveOptions.AddResolver(new CookieTenantResolver(cookieName), 400);
}
// Add Claims parser
bool enableClaim = <bool>("EnableClaim", false);
string claimType = <string>("ClaimType", "tenant");
if (enableClaim)
{
_resolveOptions.AddResolver(new ClaimTenantResolver(claimType), 500);
}
// Add a router resolver
bool enableRoute = <bool>("EnableRoute", false);
string routeParamName = <string>("RouteParamName", "tenant");
if (enableRoute)
{
_resolveOptions.AddResolver(new RouteTenantResolver(routeParamName), 600);
}
_logger.LogInformation("Configured tenant identification method: Domain={0}, Header={1}, QueryString={2}, Cookie={3}, Claim={4}, Route={5}",
enableDomain, enableHeader, enableQueryString, enableCookie, enableClaim, enableRoute);
}
public TenantInfo GetCurrentTenant()
{
return GetCurrentTenantAsync().Result;
}
}
/// <summary>
/// Tenant Identification Options
/// </summary>
public class TenantResolveOptions
{
public List<ITenantResolver> Resolvers { get; } = new List<ITenantResolver>();
public void AddResolver(ITenantResolver resolver, int priority)
{
= priority;
(resolver);
}
}
/// <summary>
/// Tenant parser interface
/// </summary>
public interface ITenantResolver
{
/// <summary>
/// Priority, the smaller the value, the higher the priority
/// </summary>
int Priority { get; set; }
/// <summary>
/// parse tenant
/// </summary>
Task<TenantInfo> ResolveTenantAsync(HttpContext context, ITenantStore tenantStore);
}
/// <summary>
/// Domain-based tenant resolver
/// </summary>
public class DomainTenantResolver : ITenantResolver
{
public int Priority { get; set; }
public async Task<TenantInfo> ResolveTenantAsync(HttpContext context, ITenantStore tenantStore)
{
string host = ();
if ((host))
{
return null;
}
// Get all tenants and find matching tenants
var tenants = await ();
return (t =>
&&
((host, ) ||
("." + , )));
}
}
/// <summary>
/// Tenant parser based on request header
/// </summary>
public class HeaderTenantResolver : ITenantResolver
{
private readonly string _headerName;
public HeaderTenantResolver(string headerName)
{
_headerName = headerName;
}
public int Priority { get; set; }
public async Task<TenantInfo> ResolveTenantAsync(HttpContext context, ITenantStore tenantStore)
{
if (!(_headerName, out var values) || == 0)
{
return null;
}
string tenantId = ();
if ((tenantId))
{
return null;
}
return await (tenantId);
}
}
/// <summary>
/// Tenant parser based on query parameters
/// </summary>
public class QueryStringTenantResolver : ITenantResolver
{
private readonly string _paramName;
public QueryStringTenantResolver(string paramName)
{
_paramName = paramName;
}
public int Priority { get; set; }
public async Task<TenantInfo> ResolveTenantAsync(HttpContext context, ITenantStore tenantStore)
{
if (!(_paramName, out var values) || == 0)
{
return null;
}
string tenantId = ();
if ((tenantId))
{
return null;
}
return await (tenantId);
}
}
/// <summary>
/// Tenant parser based on cookies
/// </summary>
public class CookieTenantResolver: ITenantResolver
{
private readonly string _cookieName;
public CookieTenantResolver(string cookieName)
{
_cookieName = cookieName;
}
public int Priority { get; set; }
public async Task<TenantInfo> ResolveTenantAsync(HttpContext context, ITenantStore tenantStore)
{
if (!(_cookieName, out string tenantId) || (tenantId))
{
return null;
}
return await (tenantId);
}
}
/// <summary>
/// Tenant parser based on Claims
/// </summary>
public class ClaimTenantResolver : ITenantResolver
{
private readonly string _claimType;
public ClaimTenantResolver(string claimType)
{
_claimType = claimType;
}
public int Priority { get; set; }
public async Task<TenantInfo> ResolveTenantAsync(HttpContext context, ITenantStore tenantStore)
{
if (!)
{
return null;
}
var claim = (c => == _claimType);
if (claim == null || ())
{
return null;
}
var tenantId = ;
return await (tenantId);
}
}
/// <summary>
/// Tenant parser based on routing parameters
/// </summary>
public class RouteTenantResolver: ITenantResolver
{
private readonly string _routeParamName;
public RouteTenantResolver(string routeParamName)
{
_routeParamName = routeParamName;
}
public int Priority { get; set; }
public async Task<TenantInfo> ResolveTenantAsync(HttpContext context, ITenantStore tenantStore)
{
if (!(_routeParamName, out var value) || value == null)
{
return null;
}
string tenantId = ();
if ((tenantId))
{
return null;
}
return await (tenantId);
}
}
}Define tenant middleware
using;
using;
using System;
using;
namespace
{
/// <summary>
/// Multi-tenant middleware, used to set up the current tenant during request processing
/// </summary>
public class TenantMiddleware
{
private readonly RequestDelegate _next;
private readonly ILogger<TenantMiddleware> _logger;
public TenantMiddleware(
RequestDelegate next,
ILogger<TenantMiddleware> logger)
{
_next = next;
_logger = logger;
}
public async Task InvokeAsync(HttpContext context, ITenantProvider tenantProvider, ITenantAccessor tenantAccessor)
{
try
{
// parse the current tenant
TenantInfo tenant = await ();
// Set the current tenant into the accessor
if (tenant != null)
{
= tenant;
_logger.LogDebug("Current tenant set: {TenantId}, {Name}", , );
// You can add tenant-related request headers or other information here
["CurrentTenant"] = tenant;
}
else
{
_logger.LogDebug("Tenant information not recognized");
}
}
catch (Exception ex)
{
_logger.LogError(ex, "An error occurred while processing tenant information");
}
// Continue to process the request
await _next(context);
}
}
}Database Migrator
using;
using System;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
using;
namespace
{
public class TenantDatabaseMigrator
{
private readonly IServiceProvider _serviceProvider;
private readonly ITenantStore _tenantStore;
private readonly ILogger<TenantDatabaseMigrator> _logger;
public TenantDatabaseMigrator(
IServiceProvider serviceProvider,
ITenantStore tenantStore,
ILogger<TenantDatabaseMigrator> logger)
{
_serviceProvider = serviceProvider;
_tenantStore = tenantStore;
_logger = logger;
}
/// <summary>
/// Migrate all tenant databases
/// </summary>
public async Task MigrateAllTenantsAsync()
{
// Get all tenants
var tenants = await _tenantStore.GetAllTenantsAsync();
foreach (var tenant in tenants)
{
try
{
await MigrateTenantDatabaseAsync(tenant);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error occurred while migrating the database of tenant {TenantId}", );
}
}
}
/// <summary>
/// Migrate the database of the specified tenant
/// </summary>
public async Task MigrateTenantDatabaseAsync(TenantInfo tenant)
{
if (tenant == null || !)
{
return;
}
_logger.LogInformation("Start migration of tenant {TenantId}' database", );
// Create a new scope so that we can use tenant-specific services
using (var scope = _serviceProvider.CreateScope())
{
// Set up the current tenant
var tenantAccessor = <ITenantAccessor>();
= tenant;
// Get DbContext and perform migration
var dbContext = new DesignTimeDefaultDbContextFactory().CreateDbContext(new string[0]);//<DefaultDbContext>();
ILogger logger = _serviceProvider.GetLogger(GetType());
(logger);
}
InitializeSeedDataAsync(tenant);
InitFrameWorkData(tenant);
}
/// <summary>
/// Initialize seed data
/// </summary>
private void InitializeSeedDataAsync(TenantInfo tenant)
{
using (var scope = _serviceProvider.CreateScope())
{
//Initialize seed data, only the seed data of the current context is initialized
IEntityManager entityManager = <IEntityManager>();
Type[] entityTypes = (typeof(DefaultDbContext)).Select(m => ).Distinct().ToArray();
IEnumerable<ISeedDataInitializer> seedDataInitializers = <ISeedDataInitializer>()
.Where(m => ()).OrderBy(m => );
try
{
ITenantAccessor tenantAccessor = <ITenantAccessor>();
= tenant;
foreach (ISeedDataInitializer initializer in seedDataInitializers)
{
();
}
var csp = <IConnectionStringProvider>();
var str = (typeof(DefaultDbContext));
_logger.LogInformation("IConnectionStringProvider link: " + str);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error occurred while initializing seed data" + );
}
}
}
private void InitFrameWorkData(TenantInfo tenant)
{
using (var scope = _serviceProvider.CreateScope())
{
ITenantAccessor tenantAccessor = <ITenantAccessor>();
= tenant;
IFunctionHandler functionHandler = <IFunctionHandler>().FirstOrDefault(m => () == typeof(MvcFunctionHandler));
if (functionHandler != null)
{
();
}
IModuleHandler moduleHandler = <IModuleHandler>();
();
//IFunctionAuthCache functionAuthCache = <IFunctionAuthCache>();
//();
IEntityInfoHandler entityInfoHandler = <IEntityInfoHandler>();
();
}
}
}
}Configuration File
{
"Logging": {
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information",
"OSharp": "Debug",
"Liuliu": "Debug"
}
},
"ConnectionStrings": {
"Tenant": "Server=(localdb)\\mssqlllocaldb;Database=MasterDb;Trusted_Connection=True;MultipleActiveResultSets=true",
"Default": "Server=(localdb)\\mssqlllocaldb;Database=DefaultDb;Trusted_Connection=True;MultipleActiveResultSets=true",
"tenant0": {
"Default": "Server=(localdb)\\mssqlllocaldb;Database=Tenant0Db;Trusted_Connection=True;MultipleActiveResultSets=true"
},
"tenant1": {
"Default": "Server=(localdb)\\mssqlllocaldb;Database=Tenant1Db;Trusted_Connection=True;MultipleActiveResultSets=true"
},
"tenant2": {
"Default": "Server=(localdb)\\mssqlllocaldb;Database=Tenant2Db;Trusted_Connection=True;MultipleActiveResultSets=true"
}
},
"MultiTenancy": {
"TenantResolve": {
"EnableDomain": true,
"EnableHeader": true,
"HeaderName": "X-Tenant",
"EnableQueryString": true,
"QueryStringName": "tenant",
"EnableCookie": true,
"CookieName": "tenant",
"EnableClaim": true,
"ClaimType": "tenant",
"EnableRoute": true,
"RouteParamName": "tenant"
}
},
"Tenants": {
"tenant0": {
"Name": "Tenant 0",
"Host": "localhost",
"ConnectionString": "Server=(localdb)\\mssqlllocaldb;Database=Tenant0Db;Trusted_Connection=True;MultipleActiveResultSets=true",
"IsEnabled": true
},
"tenant1": {
"Name": "Tenant1",
"Host": "tenant1",
"ConnectionString": "Server=(localdb)\\mssqlllocaldb;Database=Tenant1Db;Trusted_Connection=True;MultipleActiveResultSets=true",
"IsEnabled": true
},
"tenant2": {
"Name": "Tenant 2",
"Host": "tenant2",
"ConnectionString": "Server=(localdb)\\mssqlllocaldb;Database=Tenant2Db;Trusted_Connection=True;MultipleActiveResultSets=true",
"IsEnabled": true
}
},
"OSharp": {
"DbContexts": {
"SqlServer": {
"DbContextTypeName": ",",
"ConnectionString": "Server=(localdb)\\mssqlllocaldb;Database=osharpns-dev01;Trusted_Connection=True;MultipleActiveResultSets=true",
"DatabaseType": "SqlServer",
"LazyLoadingProxiesEnabled": true,
"AuditEntityEnabled": true,
"AutoMigrationEnabled": true
},
"Tenant": {
"DbContextTypeName": ",",
"ConnectionString": "Server=(localdb)\\mssqlllocaldb;Database=osharpns-dev02;Trusted_Connection=True;MultipleActiveResultSets=true",
"DatabaseType": "SqlServer",
"LazyLoadingProxiesEnabled": true,
"AuditEntityEnabled": true,
"AutoMigrationEnabled": true
}
//,
//"MySql": {
// "DbContextTypeName": ",",
// "ConnectionString": "Server=127.0.0.1;UserId=root;Password=abc123456;Database=osharpns-dev3;charset='utf8';Allow User Variables=True",
// "DatabaseType": "MySql",
// "LazyLoadingProxiesEnabled": true,
// "AuditEntityEnabled": true,
// "AutoMigrationEnabled": true
//}
//,
//"Sqlite": {
// "DbContextTypeName": ",",
// "ConnectionString": "data source=",
// "DatabaseType": "Sqlite",
// "LazyLoadingProxiesEnabled": true,
// "AuditEntityEnabled": true,
// "AutoMigrationEnabled": true
//}
//,
//"PostgreSql": {
// "DbContextTypeName": ",",
// "ConnectionString": "User ID=postgres;Password=abc123456;Host=localhost;Port=5432;Database=-dev3",
// "DatabaseType": "PostgreSql",
// "LazyLoadingProxiesEnabled": true,
// "AuditEntityEnabled": true,
// "AutoMigrationEnabled": true
//}
},
"OAuth2": {
//"QQ": {
// "ClientId": "Your QQ Internet Project AppId",
// "ClientSecret": "Your QQ Internet Project AppKey",
// "Enabled": false
//},
//"Microsoft": {
// "ClientId": "Your Microsoft project ClientId",
// "ClientSecret": "Your Microsoft project ClientSecret",
// "Enabled": false
//},
//"GitHub": {
// "ClientId": "Your Microsoft project ClientId",
// "ClientSecret": "Your Microsoft project ClientSecret",
// "Enabled": false
//}
},
"HttpEncrypt": {
"HostPrivateKey": "<RSAKeyValue><Modulus>npBAH/wQ+CzWz0cNvt7TRroWzE4dF5TvQjQqoEa+7PutPPsLYkHlCXlDWqv0gwGDc/vg9mzaxFFWFFKi+hMjwh1dkDIa9GVm3umB8Ris1j2yNqIvOEXDPpwbnCgqwP8HsnOwRG0Klqc3qjZlaaex0cv8XY/9v2l6qYkd9J0imtBLL+22bfPW+a/qtQ fvVkNAKNm6gjLLFwkXBnw3WnBNvmpqR70fe4NtIX3gIY5uWQcD5pdBmpG1uwzCatiA2b2Gso+tr/CE5nbZ7BCofIGu4Q1JSpQTzbVnLq0+e3z3ysLNZbbXHxkcTtihKOSHhkHGnSUnJZCKHaoAlNT1tAP2Q==</Modulus><Exponent>AQAB</Exponent><P>0Xm6GIcZy2C6jj0 pfhFvQfOFzOGgocXLyOJAlkZ2ULk033Xx/LdDogHzte2sxxSzuTApoJHQuCmuBIKJI74SkjAAAcRNwrhbuzLB5ulAUlTINBUHixn+PFd7m1nug0PfcTbAnapUx5n+5WTR/9zbnnfsyHXRBFumzhzByF85ibc=</P><Q>wcfJ5NkRgGDUAE8sL1Gcf5TQAJ2dK4/coHal38S2v+Hzku GGFDwICfNm/q9IzIDa72MhjBlbE7zBsRmHy2wJL/bVB1xxpfWXPZ2sHzkWeuLBEY5V1k0MaUxjFEhfgLi439IFFEPczFl3ndpNR6DYBc7Jcou0J90w9rMq2Wljcu8=</Q><DP>kHnFaX9cwhHv+YSjpoi91J3yTbHciVcTy3SJGVx15A0pM2p0wVlg808nWPYZcaGMp5BZVZ7cdviAR ioGDjndMyiaCJ3tB/0Bf6ZtaCa+L0q8XneWoVEHMXUhEq+/OpfId5xM0zGUkapbzLlxwWgBrVWHYWcpBzlzXbslyF4tIBc=</DP><DQ>WQbNxZrIhJ93prC5DwBCkwauTSocVDAi34HDETwR7bQEMH32GIO/+bpenjGvk2y7qPF1LyVTB41Xu2KMVbPLwMJ4+onJGMLs+fzfX/TdVB WrN8KZwvvg8NuMRXw+jCfRn9qgRMAsx6Fu6BGsIXVO6dQoDr0KRqpDXYPQ8tONQfc=</DQ><InverseQ>wo7bSu+OlrXYWC6EpzmFoqHrCCzVQ/Vbf/0HsMFl5CFB8k3LJjngyFDkUi/5NNNJ/BZv0oE3pk6XyHEXGlk/MZV4FCO/YrF4DSZ++ecD0/aVQDGfCNDU0HFLstBEQDhmR TQZEkkLHN8O+zjFKDzujBMY4DYZcXpFbr0srOhiDv4=</InverseQ><D>eOZgHoMhpTj7KNxyfKCF0528GFdPE1X6AC6qeb63gRZ9BsatxCKBZtJmDY7VNID6dLmhVJU/mll22FpTTs324fB/L4VBzAPn4L+s3qs83qbstET8kZfG7Zxe8bZqqzrEl+0j+k43Yzvn9FYmYVbEJgn/Y krZhsfsJDg+AiazuX3OoFfPmgArsBmiii+7nWLmMnpoiebxGS29YDl2YqrnntkcVuOpZALHDefHQdJcsNpJgFd6Dbm77ajZhpJppC4mtuUu0agUmJL3Uc6SLYHjIp/tDd2L8noZipYuNfzxxuf5KejWZM4FT6zGbU/QEurvTWMQAqp2ibixl614mUXFcKQ==</D></RSAKeyValue>",
"HostPublicKey": "<RSAKeyValue><Modulus>npBAH/wQ+CzWz0cNvt7TRroWzE4dF5TvQjQqoEa+7PutPPsLYkHlCXlDWqv0gwGDc/vg9mzaxFFWFFKi+hMjwh1dkDIa9GVm3umB8Ris1j2yNqIvOEXDPpwbnCgqwP8HsnOwRG0Klqc3qjZlaaex0cv8XY/9v2l6qYkd9J0imtBLL+22bfPW+a/qtQfvVkNAKNm6gjLLFwkXBnw3WnBNvmp qR70fe4NtIX3gIY5uWQcD5pdBmpG1uwzCatiA2b2Gso+tr/CE5nbZ7BCofIGu4Q1JSpQTzbVnLq0+e3z3ysLNZbbXHxkcTtihKOSHhkHGnSUnJZCKHaoAlNT1tAP2Q==</Modulus><Exponent>AQAB</Exponent><P></P><Q></Q><DP></DP><DQ></DQ><InverseQ></InverseQ><D></D></RSAKeyValue>",
"Enabled": false
},
"MailSender": {
"Host": "",
"Port": 587,
"EnableSsl": true,
"DisplayName": "OSharp mail send",
"UserName": "osharpsender@",
"Password": "OSharp147963"
},
"Jwt": {
"Issuer": "osharp identity",
"Audience": "osharp angular demo",
"Secret": "{8619F7C3-B53C-4B85-99F0-983D351ECD82}",
"AccessExpireMins": 5,
"RefreshExpireMins": 10080, // 7 days
"IsRefreshAbsoluteExpired": false,
"Enabled": true
},
//"Cookie": {
// "Enabled": false
//},
"Cors": {
"PolicyName": "MyCors",
"AllowAnyHeader": true,
"WithMethods": [ "POST", "PUT", "DELETE" ],
"WithOrigins": [ "" ],
"Enabled": true
},
"Redis": {
"Configuration": "localhost",
"InstanceName": "OSharpDemo:"
},
"Swagger": {
"Endpoints": [
{
"Title": "Framework API",
"Version": "v1",
"Url": "/swagger/v1/"
},
{
"Title": "Business API",
"Version": "buss",
"Url": "/swagger/buss/"
}
],
"RoutePrefix": "swagger",
"IsHideSchemas": true,
"MiniProfiler": false,
"Enabled": true
},
"Hangfire": {
"WorkerCount": 20,
"StorageConnectionString": "Server=.;Database=-dev;User Id=sa;Password=Abc123456!;MultipleActiveResultSets=true",
"DashboardUrl": "/hangfire",
"Roles": ""
}
}
}Tenant information storage configuration file
//
[
{
"tenantId": "tenant0",
"name": "Tenant 0",
"host": "localhost",
"connectionString": "Server=(localdb)\\mssqlllocaldb;Database=Tenant0Db;Trusted_Connection=True;MultipleActiveResultSets=true",
"isEnabled": true
},
{
"tenantId": "tenant1",
"name": "Tenant1",
"host": "tenant1",
"connectionString": "Server=(localdb)\\mssqlllocaldb;Database=Tenant1Db;Trusted_Connection=True;MultipleActiveResultSets=true",
"isEnabled": true
},
{
"tenantId": "tenant2",
"name": "Tenant 2",
"host": "tenant2",
"connectionString": "Server=(localdb)\\mssqlllocaldb;Database=Tenant2Db;Trusted_Connection=True;MultipleActiveResultSets=true",
"isEnabled": true
}
]Global cache interface
using;
namespace
{
/// <summary>
/// Global cache key generator interface
/// </summary>
public interface IGlobalCacheKeyGenerator
{
/// <summary>
/// Get global cache key
/// </summary>
/// <param name="args">parameters</param>
/// <returns>Cached key</returns>
string GetGlobalKey(params object[] args);
/// <summary>
/// Asynchronously obtain global cache key
/// </summary>
/// <param name="args">parameters</param>
/// <returns>Cached key</returns>
Task<string> GetGlobalKeyAsync(params object[] args);
}
}Define the cache service function interface
// -----------------------------------------------------------------------
// <copyright file="" company="OSharp open source team">
// Copyright (c) 2014-2018 OSharp. All rights reserved.
// </copyright>
// <site></site>
// <last-editor>Guo Mingfeng</last-editor>
// <last-date>2018-12-19 18:07</last-date>
// -----------------------------------------------------------------------
namespace ;
/// <summary>
/// Define cache service functions
/// </summary>
public interface ICacheService
{
/// <summary>
/// Query the results of the paging data. If the cache exists, return it directly. Otherwise, find the paging results from the data source and store it in the cache before returning
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data filter expression</param>
/// <param name="pageCondition">Pagination Condition</param>
/// <param name="selector">Data projection expression</param>
/// <param name="cacheSeconds">Cache Time</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
PageResult<TResult> ToPageCache<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
PageCondition pageCondition,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Query the results of the paging data. If the cache exists, return it directly. Otherwise, find the paging results from the data source and store it in the cache before returning
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data filter expression</param>
/// <param name="pageCondition">Pagination Condition</param>
/// <param name="selector">Data projection expression</param>
/// <param name="function">Current function information</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
PageResult<TResult> ToPageCache<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
PageCondition pageCondition,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="selector">Data filter expression</param>
/// <param name="cacheSeconds">Cache time: seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
List<TResult> ToCacheList<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="selector">Data filter expression</param>
/// <param name="cacheSeconds">Cache time: seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
TResult[] ToCacheArray<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="selector">Data filter expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
List<TResult> ToCacheList<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="selector">Data filter expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
TResult[] ToCacheArray<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="selector">Data filter expression</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
List<TResult> ToCacheList<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="selector">Data filter expression</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
TResult[] ToCacheArray<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="selector">Data filter expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
List<TResult> ToCacheList<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="selector">Data filter expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
TResult[] ToCacheArray<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <param name="source">Query data source</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
List<TSource> ToCacheList<TSource>(IQueryable<TSource> source, int cacheSeconds = 60, params object[] keyParams);
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <param name="source">Query data source</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
TSource[] ToCacheArray<TSource>(IQueryable<TSource> source, int cacheSeconds = 60, params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <param name="source">Query data source</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
List<TSource> ToCacheList<TSource>(IQueryable<TSource> source, IFunction function, params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <param name="source">Query data source</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
TSource[] ToCacheArray<TSource>(IQueryable<TSource> source, IFunction function, params object[] keyParams);
#region OutputDto
/// <summary>
/// Query the results of the paging data. If the cache exists, return it directly. Otherwise, find the paging results from the data source and store it in the cache before returning
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <typeparam name="TOutputDto">Pagination data type</typeparam>
/// <param name="source">Dataset to query</param>
/// <param name="predicate">Query condition predicate expression</param>
/// <param name="pageCondition">Pagination query conditions</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query pagination results</returns>
PageResult<TOutputDto> ToPageCache<TEntity, TOutputDto>(IQueryable<TEntity> source,
Expression<Func<TEntity, bool>> predict,
PageCondition pageCondition,
int cacheSeconds = 60,
params object[] keyParams)
where TOutputDto : IOutputDto;
/// <summary>
/// Query the results of the paging data. If the cache exists, return it directly. Otherwise, find the paging results from the data source and store it in the cache before returning
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <typeparam name="TOutputDto">Pagination data type</typeparam>
/// <param name="source">Dataset to query</param>
/// <param name="predicate">Query condition predicate expression</param>
/// <param name="pageCondition">Pagination query conditions</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query pagination results</returns>
PageResult<TOutputDto> ToPageCache<TEntity, TOutputDto>(IQueryable<TEntity> source,
Expression<Func<TEntity, bool>> predict,
PageCondition pageCondition,
IFunction function,
params object[] keyParams)
where TOutputDto : IOutputDto;
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="cacheSeconds">Cache time: seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
List<TOutputDto> ToCacheList<TSource, TOutputDto>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="cacheSeconds">Cache time: seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
TOutputDto[] ToCacheArray<TSource, TOutputDto>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
List<TOutputDto> ToCacheList<TSource, TOutputDto>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
IFunction function,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
TOutputDto[] ToCacheArray<TSource, TOutputDto>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
IFunction function,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
List<TOutputDto> ToCacheList<TSource, TOutputDto>(IQueryable<TSource> source,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
TOutputDto[] ToCacheArray<TSource, TOutputDto>(IQueryable<TSource> source,
int cacheSeconds = 60,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
List<TOutputDto> ToCacheList<TSource, TOutputDto>(IQueryable<TSource> source,
IFunction function,
params object[] keyParams);
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
TOutputDto[] ToCacheArray<TSource, TOutputDto>(IQueryable<TSource> source,
IFunction function,
params object[] keyParams);
#endregion
/// <summary>
/// Get or add global cache, regardless of tenant
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <param name="factory">Cached data acquisition factory</param>
/// <param name="expiration">Expiration time</param>
/// <returns>Cached data</returns>
T GetOrAddGlobal<T>(string key, Func<T> factory, TimeSpan? expiration = null);
/// <summary>
/// Asynchronously obtain or add global cache, regardless of tenant
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <param name="factory">Cached data acquisition factory</param>
/// <param name="expiration">Expiration time</param>
/// <returns>Cached data</returns>
Task<T> GetOrAddGlobalAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiration = null);
/// <summary>
/// Remove global cache, regardless of tenant
/// </summary>
/// <param name="key">Cached key</param>
void RemoveGlobal(string key);
/// <summary>
/// Asynchronously remove global cache, regardless of tenant
/// </summary>
/// <param name="key">Cached key</param>
Task RemoveGlobalAsync(string key);
// Add the following method to the ICacheService interface
/// <summary>
/// Set cache
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <param name="value">Cached value</param>
/// <param name="expiration">Expiration time</param>
void Set<T>(string key, T value, TimeSpan? expiration = null);
/// <summary>
/// Asynchronously set cache
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <param name="value">Cached value</param>
/// <param name="expiration">Expiration time</param>
/// <returns>Async Tasks</returns>
Task SetAsync<T>(string key, T value, TimeSpan? expiration = null);
/// <summary>
/// Get cache
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <returns>Cached data</returns>
T Get<T>(string key);
/// <summary>
/// Asynchronously obtain cache
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <returns>Cached data</returns>
Task<T> GetAsync<T>(string key);
}Cache service implementation
// -----------------------------------------------------------------------
// <copyright file="" company="OSharp open source team">
// Copyright (c) 2014-2018 OSharp. All rights reserved.
// </copyright>
// <site></site>
// <last-editor>Guo Mingfeng</last-editor>
// <last-date>2018-12-19 19:10</last-date>
// -----------------------------------------------------------------------
using;
namespace ;
/// <summary>
/// Implementation of cache service
/// </summary>
public class CacheService : ICacheService
{
private readonly IDistributedCache _cache;
private readonly ICacheKeyGenerator _keyGenerator;
private readonly IGlobalCacheKeyGenerator _globalKeyGenerator;
private readonly ILogger<CacheService> _logger;
private readonly IServiceProvider _serviceProvider;
/// <summary>
/// Initialize a new instance of type <see cref="CacheService"/>
/// </summary>
public CacheService(
IDistributedCache cache,
ICacheKeyGenerator keyGenerator,
ILogger<CacheService> logger,
IServiceProvider serviceProvider)
{
_cache = cache;
_keyGenerator = keyGenerator;
_globalKeyGenerator = keyGenerator as IGlobalCacheKeyGenerator;
_logger = logger;
_serviceProvider = serviceProvider;
}
#region Implementation of ICacheService
/// <summary>
/// Query the results of the paging data. If the cache exists, return it directly. Otherwise, find the paging results from the data source and store it in the cache before returning
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data filter expression</param>
/// <param name="pageCondition">Pagination Condition</param>
/// <param name="selector">Data projection expression</param>
/// <param name="cacheSeconds">Cache Time</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual PageResult<TResult> ToPageCache<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
PageCondition pageCondition,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams)
{
string key = GetKey(source, predict, pageCondition, selector, keyParams);
return _cache.Get(key, () => (predicate, pageCondition, selector), cacheSeconds);
}
/// <summary>
/// Query the results of the paging data. If the cache exists, return it directly. Otherwise, find the paging results from the data source and store it in the cache before returning
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data filter expression</param>
/// <param name="pageCondition">Pagination Condition</param>
/// <param name="selector">Data projection expression</param>
/// <param name="function">Current function information</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual PageResult<TResult> ToPageCache<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
PageCondition pageCondition,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams)
{
string key = GetKey(source, predict, pageCondition, selector, keyParams);
return _cache.Get(key, () => (predicate, pageCondition, selector), function);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="selector">Data filter expression</param>
/// <param name="cacheSeconds">Cache time: seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual List<TResult> ToCacheList<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams)
{
return ToCacheList((predicate), selector, cacheSeconds, keyParams);
}
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="selector">Data filter expression</param>
/// <param name="cacheSeconds">Cache time: seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual TResult[] ToCacheArray<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams)
{
return ToCacheArray((predicate), selector, cacheSeconds, keyParams);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="selector">Data filter expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual List<TResult> ToCacheList<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams)
{
return ToCacheList((predicate), selector, function, keyParams);
}
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="selector">Data filter expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual TResult[] ToCacheArray<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams)
{
return ToCacheArray((predicate), selector, function, keyParams);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="selector">Data filter expression</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual List<TResult> ToCacheList<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams)
{
string key = GetKey(source, selector, keyParams);
return _cache.Get(key, () => (selector).ToList(), cacheSeconds);
}
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="selector">Data filter expression</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual TResult[] ToCacheArray<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
int cacheSeconds = 60,
params object[] keyParams)
{
string key = GetKey(source, selector, keyParams);
return _cache.Get(key, () => (selector).ToArray(), cacheSeconds);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="selector">Data filter expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual List<TResult> ToCacheList<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams)
{
string key = GetKey(source, selector, keyParams);
return _cache.Get(key, () => (selector).ToList(), function);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TResult">Item data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="selector">Data filter expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual TResult[] ToCacheArray<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
IFunction function,
params object[] keyParams)
{
string key = GetKey(source, selector, keyParams);
return _cache.Get(key, () => (selector).ToArray(), function);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <param name="source">Query data source</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual List<TSource> ToCacheList<TSource>(IQueryable<TSource> source, int cacheSeconds = 60, params object[] keyParams)
{
string key = GetKey(, keyParams);
return _cache.Get(key, , cacheSeconds);
}
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <param name="source">Query data source</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual TSource[] ToCacheArray<TSource>(IQueryable<TSource> source, int cacheSeconds = 60, params object[] keyParams)
{
string key = GetKey(, keyParams);
return _cache.Get(key, , cacheSeconds);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <param name="source">Query data source</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual List<TSource> ToCacheList<TSource>(IQueryable<TSource> source, IFunction function, params object[] keyParams)
{
if (function == null || <= 0)
{
return ();
}
string key = GetKey(, keyParams);
return _cache.Get(key, , function);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <param name="source">Query data source</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual TSource[] ToCacheArray<TSource>(IQueryable<TSource> source, IFunction function, params object[] keyParams)
{
if (function == null || <= 0)
{
return ();
}
string key = GetKey(, keyParams);
return _cache.Get(key, , function);
}
/// <summary>
/// Query the results of the paging data. If the cache exists, return it directly. Otherwise, find the paging results from the data source and store it in the cache before returning
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <typeparam name="TOutputDto">Pagination data type</typeparam>
/// <param name="source">Dataset to query</param>
/// <param name="predicate">Query condition predicate expression</param>
/// <param name="pageCondition">Pagination query conditions</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query pagination results</returns>
public virtual PageResult<TOutputDto> ToPageCache<TEntity, TOutputDto>(IQueryable<TEntity> source,
Expression<Func<TEntity, bool>> predict,
PageCondition pageCondition,
int cacheSeconds = 60,
params object[] keyParams) where TOutputDto : IOutputDto
{
string key = GetKey<TEntity, TOutputDto>(source, predict, pageCondition, keyParams);
return _cache.Get(key, () => <TEntity, TOutputDto>(predicate, pageCondition), cacheSeconds);
}
/// <summary>
/// Query the results of the paging data. If the cache exists, return it directly. Otherwise, find the paging results from the data source and store it in the cache before returning
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <typeparam name="TOutputDto">Pagination data type</typeparam>
/// <param name="source">Dataset to query</param>
/// <param name="predicate">Query condition predicate expression</param>
/// <param name="pageCondition">Pagination query conditions</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query pagination results</returns>
public virtual PageResult<TOutputDto> ToPageCache<TEntity, TOutputDto>(IQueryable<TEntity> source,
Expression<Func<TEntity, bool>> predict,
PageCondition pageCondition,
IFunction function,
params object[] keyParams) where TOutputDto : IOutputDto
{
string key = GetKey<TEntity, TOutputDto>(source, predict, pageCondition, keyParams);
return _cache.Get(key, () => <TEntity, TOutputDto>(predicate, pageCondition), function);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="cacheSeconds">Cache time: seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual List<TOutputDto> ToCacheList<TSource, TOutputDto>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
int cacheSeconds = 60,
params object[] keyParams)
{
return ToCacheList<TSource, TOutputDto>((predicate), cacheSeconds, keyParams);
}
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="cacheSeconds">Cache time: seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual TOutputDto[] ToCacheArray<TSource, TOutputDto>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
int cacheSeconds = 60,
params object[] keyParams)
{
return ToCacheArray<TSource, TOutputDto>((predicate), cacheSeconds, keyParams);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual List<TOutputDto> ToCacheList<TSource, TOutputDto>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
IFunction function,
params object[] keyParams)
{
return ToCacheList<TSource, TOutputDto>((predicate), function, keyParams);
}
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Item data type of data source</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Data source</param>
/// <param name="predicate">Data query expression</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns></returns>
public virtual TOutputDto[] ToCacheArray<TSource, TOutputDto>(IQueryable<TSource> source,
Expression<Func<TSource, bool>> predict,
IFunction function,
params object[] keyParams)
{
return ToCacheArray<TSource, TOutputDto>((predicate), function, keyParams);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual List<TOutputDto> ToCacheList<TSource, TOutputDto>(IQueryable<TSource> source, int cacheSeconds = 60, params object[] keyParams)
{
string key = GetKey<TSource, TOutputDto>(source, keyParams);
return _cache.Get(key, () => <TSource, TOutputDto>().ToList(), cacheSeconds);
}
/// <summary>
/// Convert the result to a cached array. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache before returning it.
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="cacheSeconds">Cached seconds</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual TOutputDto[] ToCacheArray<TSource, TOutputDto>(IQueryable<TSource> source, int cacheSeconds = 60, params object[] keyParams)
{
string key = GetKey<TSource, TOutputDto>(source, keyParams);
return _cache.Get(key, () => <TSource, TOutputDto>().ToArray(), cacheSeconds);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual List<TOutputDto> ToCacheList<TSource, TOutputDto>(IQueryable<TSource> source, IFunction function, params object[] keyParams)
{
string key = GetKey<TSource, TOutputDto>(source, keyParams);
return _cache.Get(key, () => <TSource, TOutputDto>().ToList(), function);
}
/// <summary>
/// Convert the result to a cached list. If the cache exists, return it directly. Otherwise, query it from the data source and store it in the cache according to the specified cache policy before returning
/// </summary>
/// <typeparam name="TSource">Source data type</typeparam>
/// <typeparam name="TOutputDto">Element data type of the result set</typeparam>
/// <param name="source">Query data source</param>
/// <param name="function">Cache policy-related functions</param>
/// <param name="keyParams">Cached key parameters</param>
/// <returns>Query results</returns>
public virtual TOutputDto[] ToCacheArray<TSource, TOutputDto>(IQueryable<TSource> source, IFunction function, params object[] keyParams)
{
string key = GetKey<TSource, TOutputDto>(source, keyParams);
return _cache.Get(key, () => <TSource, TOutputDto>().ToArray(), function);
}
#endregion
#region Private Method
private string GetKey<TEntity, TResult>(IQueryable<TEntity> source,
Expression<Func<TEntity, bool>> predict,
PageCondition pageCondition,
Expression<Func<TEntity, TResult>> selector,
params object[] keyParams)
{
source = (predicate);
SortCondition[] sortConditions = ;
if (sortConditions == null || == 0)
{
if (typeof(TEntity).IsEntityType())
{
source = ("Id");
}
else if (typeof(TEntity).IsBaseOn<ICreatedTime>())
{
source = ("CreatedTime");
}
else
{
throw new OsharpException($"type "{typeof(TEntity)}" has not added the default sorting method");
}
}
else
{
int count = 0;
IOrderedQueryable<TEntity> orderSource = null;
foreach (SortCondition sortCondition in sortConditions)
{
orderSource = count == 0
? CollectionPropertySorter<TEntity>.OrderBy(source, , )
: CollectionPropertySorter<TEntity>.ThenBy(orderSource, , );
count++;
}
source = orderSource;
}
int pageIndex = , pageSize = ;
source = source != null
? ((pageIndex - 1) * pageSize).Take(pageSize)
: <TEntity>().AsQueryable();
IQueryable<TResult> query = (selector);
return GetKey(, keyParams);
}
private string GetKey<TEntity, TOutputDto>(IQueryable<TEntity> source,
Expression<Func<TEntity, bool>> predict,
PageCondition pageCondition,
params object[] keyParams)
where TOutputDto : IOutputDto
{
source = (predicate);
SortCondition[] sortConditions = ;
if (sortConditions == null || == 0)
{
if (typeof(TEntity).IsEntityType())
{
source = ("Id");
}
else if (typeof(TEntity).IsBaseOn<ICreatedTime>())
{
source = ("CreatedTime");
}
else
{
throw new OsharpException($"type "{typeof(TEntity)}" has not added the default sorting method");
}
}
else
{
int count = 0;
IOrderedQueryable<TEntity> orderSource = null;
foreach (SortCondition sortCondition in sortConditions)
{
orderSource = count == 0
? CollectionPropertySorter<TEntity>.OrderBy(source, , )
: CollectionPropertySorter<TEntity>.ThenBy(orderSource, , );
count++;
}
source = orderSource;
}
int pageIndex = , pageSize = ;
source = source != null
? ((pageIndex - 1) * pageSize).Take(pageSize)
: <TEntity>().AsQueryable();
IQueryable<TOutputDto> query = <TEntity, TOutputDto>(true);
return GetKey(, keyParams);
}
private string GetKey<TSource, TOutputDto>(IQueryable<TSource> source,
params object[] keyParams)
{
IQueryable<TOutputDto> query = <TSource, TOutputDto>(true);
return GetKey(, keyParams);
}
private string GetKey<TSource, TResult>(IQueryable<TSource> source,
Expression<Func<TSource, TResult>> selector,
params object[] keyParams)
{
IQueryable<TResult> query = (selector);
return GetKey(, keyParams);
}
private string GetKey(Expression expression, params object[] keyParams)
{
string key;
try
{
key = new ExpressionCacheKeyGenerator(expression).GetKey(keyParams);
}
catch (TargetInvocationException)
{
key = new StringCacheKeyGenerator().GetKey(keyParams);
}
key = $"Query:{key.ToMd5Hash()}";
_logger.LogDebug($"get cache key: {key}");
return key;
}
#endregion
/// <summary>
/// Get or add global cache, regardless of tenant
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <param name="factory">Cached data acquisition factory</param>
/// <param name="expiration">Expiration time</param>
/// <returns>Cached data</returns>
public T GetOrAddGlobal<T>(string key, Func<T> factory, TimeSpan? expiration = null)
{
(key, nameof(key));
(factory, nameof(factory));
if (_globalKeyGenerator == null)
{
throw new OsharpException("The current cache key generator does not support global cache key generation");
}
string cacheKey = _globalKeyGenerator.GetGlobalKey(key);
T result = Get<T>(cacheKey);
if (!Equals(result, default(T)))
{
return result;
}
result = factory();
if (Equals(result, default(T)))
{
return default;
}
Set(cacheKey, result, expiration);
return result;
}
/// <summary>
/// Asynchronously obtain or add global cache, regardless of tenant
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <param name="factory">Cached data acquisition factory</param>
/// <param name="expiration">Expiration time</param>
/// <returns>Cached data</returns>
public async Task<T> GetOrAddGlobalAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiration = null)
{
(key, nameof(key));
(factory, nameof(factory));
if (_globalKeyGenerator == null)
{
throw new OsharpException("The current cache key generator does not support global cache key generation");
}
string cacheKey = await _globalKeyGenerator.GetGlobalKeyAsync(key);
T result = await GetAsync<T>(cacheKey);
if (!Equals(result, default(T)))
{
return result;
}
result = await factory();
if (Equals(result, default(T)))
{
return default;
}
await SetAsync(cacheKey, result, expiration);
return result;
}
/// <summary>
/// Remove global cache, regardless of tenant
/// </summary>
/// <param name="key">Cached key</param>
public void RemoveGlobal(string key)
{
(key, nameof(key));
if (_globalKeyGenerator == null)
{
throw new OsharpException("The current cache key generator does not support global cache key generation");
}
string cacheKey = _globalKeyGenerator.GetGlobalKey(key);
_cache.Remove(cacheKey);
}
/// <summary>
/// Asynchronously remove global cache, regardless of tenant
/// </summary>
/// <param name="key">Cached key</param>
public async Task RemoveGlobalAsync(string key)
{
(key, nameof(key));
if (_globalKeyGenerator == null)
{
throw new OsharpException("The current cache key generator does not support global cache key generation");
}
string cacheKey = await _globalKeyGenerator.GetGlobalKeyAsync(key);
await _cache.RemoveAsync(cacheKey);
}
// Add the following method in the CacheService class
/// <summary>
/// Set cache
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <param name="value">Cached value</param>
/// <param name="expiration">Expiration time</param>
public void Set<T>(string key, T value, TimeSpan? expiration = null)
{
(key, nameof(key));
if (value == null)
{
return;
}
var options = new DistributedCacheEntryOptions();
if ()
{
= expiration;
}
string json = (value);
_cache.SetString(key, json, options);
}
/// <summary>
/// Asynchronously set cache
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <param name="value">Cached value</param>
/// <param name="expiration">Expiration time</param>
/// <returns>Async Tasks</returns>
public async Task SetAsync<T>(string key, T value, TimeSpan? expiration = null)
{
(key, nameof(key));
if (value == null)
{
return;
}
var options = new DistributedCacheEntryOptions();
if ()
{
= expiration;
}
string json = (value);
await _cache.SetStringAsync(key, json, options);
}
/// <summary>
/// Get cache
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <returns>Cached data</returns>
public T Get<T>(string key)
{
(key, nameof(key));
string json = _cache.GetString(key);
if ((json))
{
return default;
}
return <T>(json);
}
/// <summary>
/// Asynchronously obtain cache
/// </summary>
/// <typeparam name="T">Cache data type</typeparam>
/// <param name="key">Cached key</param>
/// <returns>Cached data</returns>
public async Task<T> GetAsync<T>(string key)
{
(key, nameof(key));
string json = await _cache.GetStringAsync(key);
if ((json))
{
return default;
}
return <T>(json);
}
}