public override void OnConfigureServices(ServiceConfigurationContext context)
{
context.Services.ConfigureDynamicProxy(o => {
//添加AOP的配置
});
var RedisConfiguration = context.Configuration.GetSection("Redis");
context.Services.Configure <RedisOption>(RedisConfiguration);
RedisOption redisOption = RedisConfiguration.Get <RedisOption>();
if (redisOption != null && redisOption.Enable)
{
var options = new RedisCacheOptions
{
InstanceName = redisOption.InstanceName,
Configuration = redisOption.Connection
};
var redis = new RedisCacheHelper(options, redisOption.Database);
context.Services.AddSingleton(redis);
context.Services.AddSingleton <ICacheHelper>(redis);
}
else
{
context.Services.AddMemoryCache();
context.Services.AddScoped <ICacheHelper, MemoryCacheHelper>();
}
context.Services.Configure <QiNiuOssModel>(context.Configuration.GetSection("QiNiuOss"));
context.Services.AddScoped <QiniuCloud>();
}
/// <summary>
/// 初始化Db
/// </summary>
/// <param name="redisOption"></param>
public static void Init(RedisOption redisOption /*ConnectionMultiplexer _redisConnectionMultiplexer, string _instanceName, */)
{
instanceName = redisOption.InstanceName;
_redisOption = redisOption;
_redis = GetConnect();
db = GetDatabase();
}
/// <summary>
/// 配置变更
/// </summary>
private static void OnOptionChange()
{
Option = ConfigurationHelper.Get <RedisOption>("Redis") ?? new RedisOption();
foreach (var client in Instances)
{
client.OnOptionChange(Option);
}
}
/// <summary>
/// 配置缓存
/// </summary>
/// <param name="option">Redis选项配置</param>
/// <returns></returns>
public static void Config(RedisOption option = null)
{
_redisValid = false;
_memCache = new MemoryCache(true, 60, 0, true);
if (option != null)
{
_redisCache = new RedisClient(option);
CreateMonitorTask(); // 创建监控任务
}
}
static RedisConfig()
{
RedisOption option = AppConfig.RedisOption;
if (option != null)
{
SysCustomKey = option.RedisPrefixKey;
RedisConnectionString = option.RedisConnectionString;
}
else
{
throw new Exception($"未加载redis.json文件");
}
}
public static IServiceCollection AddYaeHerCsRedisCache(this IServiceCollection services, Action <RedisOption> setupAction)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (setupAction == null)
{
throw new ArgumentNullException(nameof(setupAction));
}
var options = new RedisOption();
services.AddOptions();
services.Configure(setupAction);
services.AddScoped <IRedisBinarySerializer, JsonRedisBinarySerializer>();
services.AddScoped <IRedisClientProvider, CsRedisRedisClientProvider>();
return(services);
}
private async Task ExecuteRedisServiceAsync(RedisOption option)
{
Console.WriteLine("Start working with Redis...");
if (!string.IsNullOrEmpty(option.Key))
{
if (option.Read)
{
Console.WriteLine(await _redisService.GetString(option.Key));
}
if (option.Write)
{
if (!string.IsNullOrEmpty(option.Value))
{
Console.WriteLine(await _redisService.SetString(option.Key, option.Value));
}
else
{
Console.WriteLine("Key is required.");
}
}
}
}
void TestRedis()
{
var redisOp = RedisOption.BuildRedisOption(ConnectString);
AppendLine(tb_Output, $"Current RedisOption is {redisOp}");
var client = new RedisClient(redisOp);
bool flag = client.IsConnected;
AppendLine(tb_Output, $"Current RedisClient is IsConnected {flag},If False While Try Auth With Password({redisOp.Password})");
if (!flag && !string.IsNullOrEmpty(redisOp.Password))
{
try
{
var authRet = client.Auth(redisOp.Password);
AppendLine(tb_Output, $"client.Auth({redisOp.Password})->{authRet} [Success]");
flag = true;
}
catch (Exception ex)
{
AppendLine(tb_Output, $"client.Auth({redisOp.Password})-> [Failed] Handler Error {ex.Message}\r\n{ex}");
flag = false;
}
}
if (!flag)
{
return;
}
if (redisOp.DefaultDb > 0)
{
try
{
var selectRet = client.Select(redisOp.DefaultDb);
AppendLine(tb_Output, $"client.Select(db:{redisOp.DefaultDb})->{selectRet} [Success]");
flag = true;
}
catch (Exception ex)
{
AppendLine(tb_Output, $"client.Select(db:{redisOp.DefaultDb}) [Failed] Handler Error {ex.Message}\r\n{ex}");
flag = false;
}
}
if (!flag)
{
return;
}
try
{
var clientListRet = client.ClientList().Replace("\n", "\r\n");
AppendLine(tb_Output, $"client.ClientList()->\r\n{clientListRet} ");
}
catch (Exception ex)
{
AppendLine(tb_Output, $"client.ClientList() [Failed] Handler Error {ex.Message}\r\n{ex}");
}
try
{
var clientInfoRet = client.Info();
AppendLine(tb_Output, $"client.Info()->\r\n{clientInfoRet}");
}
catch (Exception ex)
{
AppendLine(tb_Output, $"client.Info() [Failed] Handler Error {ex.Message}\r\n{ex}");
}
try
{
var quitRet = client.Quit();
AppendLine(tb_Output, $"{ConnectString} Close Success ->{quitRet}");
flag = true;
}
catch (Exception ex)
{
AppendLine(tb_Output, $"{ConnectString} Close Handler Error {ex.Message}\r\n{ex}");
flag = false;
}
}
public RedisHelper(IOptions <RedisOption> redisOption)
{
_redisOption = redisOption.Value;
}
public CsRedisRedisClient(RedisOption redisOption, IRedisBinarySerializer redisBinarySerializer)
{
RedisOption = redisOption;
Serializer = redisBinarySerializer;
}
/// <summary>
/// 创建RedisClient
/// </summary>
/// <param name="option">配置</param>
/// <returns></returns>
public RedisClient Create(RedisOption option)
{
return(new RedisClient(option));
}
public IRedisClient CreateClient(RedisOption redisCacheOption, IRedisBinarySerializer serializer)
{
return(new CsRedisRedisClient(redisCacheOption, serializer));
}
public CsRedisRedisClientProvider(IRedisBinarySerializer redisBinarySerializer, IOptionsMonitor <RedisOption> optionsMonitor)
{
_redisBinarySerializer = redisBinarySerializer;
_redisOption = optionsMonitor.CurrentValue;
}
/// <summary>
/// 配置变更
/// </summary>
/// <param name="option"></param>
public void OnOptionChange(RedisOption option)
{
Option = option;
_client = null;
_clients.Clear();
}
