internal static void ParseHosts(RedisConfigurationSetting setting, string host)
{
if (!string.IsNullOrEmpty(host))
{
host.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ForEach(s => setting.Hosts.Add(new RedisHost(s)));
}
}
/// <summary>
/// 初始化 <see cref="RedisLocker"/> 类的新实例。
/// </summary>
/// <param name="options"></param>
public RedisLocker(IServiceProvider serviceProvider, IOptionsMonitor <RedisDistributedLockerOptions> options)
: this(serviceProvider)
{
RedisConfigurationSetting setting = null;
var optValue = options.CurrentValue;
if (!optValue.IsConfigured())
{
var section = ConfigurationUnity.GetSection <LockerConfigurationSection>();
var matchSetting = section.Settings.FirstOrDefault(s => s.Value.LockerType == typeof(RedisLocker)).Value;
if (matchSetting != null && section.GetSetting(matchSetting.Name) is ExtendConfigurationSetting extSetting)
{
setting = (RedisConfigurationSetting)extSetting.Extend;
}
else
{
throw new InvalidOperationException($"未发现与 {typeof(RedisLocker).FullName} 相匹配的配置。");
}
}
else
{
if (!string.IsNullOrEmpty(optValue.ConfigName))
{
var section = ConfigurationUnity.GetSection <LockerConfigurationSection>();
if (section != null && section.GetSetting(optValue.ConfigName) is ExtendConfigurationSetting extSetting)
{
setting = (RedisConfigurationSetting)extSetting.Extend;
}
else
{
throw new InvalidOperationException($"无效的配置节: {optValue.ConfigName}。");
}
}
else
{
setting = new RedisConfigurationSetting
{
Password = optValue.Password,
ConnectionString = optValue.ConnectionString,
DefaultDb = optValue.DefaultDb,
ConnectTimeout = optValue.ConnectTimeout,
LockTimeout = optValue.LockTimeout,
SyncTimeout = optValue.SyncTimeout,
WriteBuffer = optValue.WriteBuffer,
PoolSize = optValue.PoolSize,
SerializerType = optValue.SerializerType,
Ssl = optValue.Ssl,
Twemproxy = optValue.Twemproxy
};
RedisHelper.ParseHosts(setting, optValue.Hosts);
}
}
if (setting != null)
{
(this as IConfigurationSettingHostService).Attach(setting);
}
}
public IConfigurationSettingItem Parse(IConfiguration configuration)
{
var setting = new RedisConfigurationSetting();
setting.ConnectionString = configuration["connectionString"];
setting.Twemproxy = configuration["twemproxy"].To(false);
var configNode = configuration.GetSection("config");
if (configNode.Exists())
{
var serializerType = configNode["serializerType"];
if (!string.IsNullOrEmpty(serializerType))
{
setting.SerializerType = serializerType.ParseType();
}
setting.PoolSize = configNode["poolSize"].To <int?>();
setting.DefaultDb = configNode["defaultDb"].To(0);
setting.DbRange = configNode["dbRange"];
setting.KeyRule = configNode["keyRule"];
setting.Password = configNode["password"];
setting.Ssl = configNode["ssl"].To <bool>();
setting.WriteBuffer = configNode["writeBuffer"].To <int?>();
setting.LockTimeout = configNode["lockTimeout"].ToTimeSpan(TimeSpan.FromSeconds(10));
setting.ConnectTimeout = configNode["connectTimeout"].ToTimeSpan(TimeSpan.FromMilliseconds(5000));
setting.SyncTimeout = configNode["syncTimeout"].ToTimeSpan(TimeSpan.FromMilliseconds(10000));
setting.RetryDelayTime = configNode["retryDelayTime"].ToTimeSpan(TimeSpan.FromSeconds(20));
setting.RetryTimes = configNode["retryTimes"].To <int?>();
setting.SlidingTime = configNode["slidingTime"].ToTimeSpan();
setting.IgnoreException = configNode["ignoreException"].To(true);
var hosts = configNode.GetSection("hosts");
if (!hosts.Exists())
{
hosts = configNode.GetSection("host");
}
foreach (var nd in hosts.GetChildren())
{
var host = new RedisHost(nd["server"], nd["port"].To(0))
{
ReadOnly = nd["readonly"].To(false)
};
setting.Hosts.Add(host);
}
}
return(setting);
}
public IConfigurationSettingItem Parse(System.Xml.XmlNode section)
{
var setting = new RedisConfigurationSetting();
setting.ConnectionString = section.GetAttributeValue("connectionString");
setting.Twemproxy = section.GetAttributeValue <bool>("twemproxy");
var configNode = section.SelectSingleNode("config");
if (configNode != null)
{
var serializerType = configNode.GetAttributeValue("serializerType");
if (!string.IsNullOrEmpty(serializerType))
{
setting.SerializerType = serializerType.ParseType();
}
setting.PoolSize = configNode.GetAttributeValue <int?>("poolSize");
setting.DefaultDb = configNode.GetAttributeValue("defaultDb", 0);
setting.DbRange = configNode.GetAttributeValue("dbRange");
setting.KeyRule = configNode.GetAttributeValue("keyRule");
setting.Password = configNode.GetAttributeValue("password");
setting.Ssl = configNode.GetAttributeValue <bool>("ssl");
setting.WriteBuffer = configNode.GetAttributeValue <int?>("writeBuffer");
setting.LockTimeout = configNode.GetAttributeValue("lockTimeout").ToTimeSpan(TimeSpan.FromSeconds(10));
setting.ConnectTimeout = configNode.GetAttributeValue("connectTimeout").ToTimeSpan(TimeSpan.FromMilliseconds(5000));
setting.SyncTimeout = configNode.GetAttributeValue("syncTimeout").ToTimeSpan(TimeSpan.FromMilliseconds(10000));
setting.RetryDelayTime = configNode.GetAttributeValue("retryDelayTime").ToTimeSpan(TimeSpan.FromSeconds(20));
setting.RetryTimes = configNode.GetAttributeValue("retryTimes").To <int?>();
setting.SlidingTime = configNode.GetAttributeValue("slidingTime").ToTimeSpan();
setting.IgnoreException = configNode.GetAttributeValue("ignoreException").To(true);
foreach (XmlNode nd in configNode.SelectNodes("host"))
{
var host = new RedisHost(nd.GetAttributeValue("server"), nd.GetAttributeValue("port", 0))
{
ReadOnly = nd.GetAttributeValue("readonly", false)
};
setting.Hosts.Add(host);
}
}
return(setting);
}
internal RedisHashSet(
RedisConfigurationSetting setting,
string cacheKey,
Func <IEnumerable <Tuple <TKey, TValue, ICacheItemExpiration> > > initializeSet,
CSRedisClient client,
Func <RedisCacheItem <TValue>, string> serialize,
Func <string, RedisCacheItem <TValue> > deserialize,
bool checkExpiration)
{
_setting = setting;
_cacheKey = cacheKey;
_client = client;
_serialize = serialize;
_deserialize = deserialize;
_initializeSet = initializeSet;
Initialize();
if (checkExpiration)
{
StartExpireTask();
}
}
public IConfigurationSettingItem Parse(IConfiguration configuration)
{
var setting = new RedisConfigurationSetting();
setting.ConnectionString = configuration["connectionString"];
setting.Twemproxy = configuration["twemproxy"].To(false);
var configNode = configuration.GetSection("config");
if (configNode.Exists())
{
var serializerType = configNode["serializerType"];
if (!string.IsNullOrEmpty(serializerType))
{
setting.SerializerType = serializerType.ParseType();
}
setting.PoolSize = configNode["poolSize"].To <int?>();
setting.DefaultDb = configNode["defaultDb"].To(0);
setting.Password = configNode["password"];
setting.Ssl = configNode["ssl"].To <bool>();
setting.WriteBuffer = configNode["writeBuffer"].To <int?>();
setting.AdvanceDelay = configNode["advanceDelay"].To <double?>();
setting.LockTimeout = configNode["lockTimeout"].To(10);
foreach (var nd in configNode.GetSection("host").GetChildren())
{
var host = new RedisHost();
host.Server = nd["server"];
host.Port = nd["port"].To(0);
host.ReadOnly = nd["readonly"].To(false);
setting.Hosts.Add(host);
}
}
return(setting);
}
public IConfigurationSettingItem Parse(System.Xml.XmlNode section)
{
var setting = new RedisConfigurationSetting();
setting.ConnectionString = section.GetAttributeValue("connectionString");
setting.Twemproxy = section.GetAttributeValue <bool>("twemproxy");
var configNode = section.SelectSingleNode("config");
if (configNode != null)
{
var serializerType = configNode.GetAttributeValue("serializerType");
if (!string.IsNullOrEmpty(serializerType))
{
setting.SerializerType = serializerType.ParseType();
}
setting.PoolSize = configNode.GetAttributeValue <int?>("poolSize");
setting.DefaultDb = configNode.GetAttributeValue("defaultDb", 0);
setting.Password = configNode.GetAttributeValue("password");
setting.Ssl = configNode.GetAttributeValue <bool>("ssl");
setting.WriteBuffer = configNode.GetAttributeValue <int?>("writeBuffer");
setting.AdvanceDelay = configNode.GetAttributeValue <double?>("advanceDelay");
setting.LockTimeout = configNode.GetAttributeValue("lockTimeout", 10);
foreach (XmlNode nd in configNode.SelectNodes("host"))
{
var host = new RedisHost();
host.Server = nd.GetAttributeValue("server");
host.Port = nd.GetAttributeValue("port", 0);
host.ReadOnly = nd.GetAttributeValue("readonly", false);
setting.Hosts.Add(host);
}
}
return(setting);
}
void IConfigurationSettingHostService.Attach(IConfigurationSettingItem setting)
{
this.Setting = (RedisConfigurationSetting)setting;
#if NETSTANDARD
var connectionStrs = new List <string>();
if (!string.IsNullOrEmpty(this.Setting.ConnectionString))
{
connectionStrs.Add(this.Setting.ConnectionString);
}
else
{
foreach (var host in this.Setting.Hosts)
{
var connStr = new StringBuilder($"{host.Server}");
#region connection build
if (host.Port != 0)
{
connStr.Append($":{host.Port}");
}
if (!string.IsNullOrEmpty(this.Setting.Password))
{
connStr.Append($",password={this.Setting.Password}");
}
if (this.Setting.DefaultDb != 0)
{
connStr.Append($",defaultDatabase={this.Setting.DefaultDb}");
}
connStr.Append(",allowAdmin=true");
#endregion
connectionStrs.Add(connStr.ToString());
}
}
connectionLazy = new Lazy <CSRedisClient>(() => new CSRedisClient(null, connectionStrs.ToArray()));
#else
if (!string.IsNullOrEmpty(this.Setting.ConnectionString))
{
Options = ConfigurationOptions.Parse(this.Setting.ConnectionString);
}
else
{
Options = new ConfigurationOptions
{
DefaultDatabase = this.Setting.DefaultDb,
Password = this.Setting.Password,
AllowAdmin = true,
Proxy = this.Setting.Twemproxy ? Proxy.Twemproxy : Proxy.None,
AbortOnConnectFail = false
};
if (this.Setting.ConnectTimeout != null)
{
Options.ConnectTimeout = (int)this.Setting.ConnectTimeout;
}
foreach (var host in this.Setting.Hosts)
{
if (host.Port == 0)
{
Options.EndPoints.Add(host.Server);
}
else
{
Options.EndPoints.Add(host.Server, host.Port);
}
}
}
connectionLazy = new Lazy <ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(Options));
#endif
}
void IConfigurationSettingHostService.Attach(IConfigurationSettingItem setting)
{
if (Setting != null)
{
return;
}
Setting = (RedisConfigurationSetting)setting;
if (!string.IsNullOrEmpty(Setting.ConnectionString))
{
_connectionStrs.Add(Setting.ConnectionString);
}
else
{
foreach (var host in Setting.Hosts)
{
var connStr = new StringBuilder($"{host.Server}");
#region connection build
if (host.Port != 0)
{
connStr.Append($":{host.Port}");
}
if (!string.IsNullOrEmpty(Setting.Password))
{
connStr.Append($",password={Setting.Password}");
}
if (Setting.DefaultDb != 0 && string.IsNullOrEmpty(Setting.DbRange))
{
connStr.Append($",defaultDatabase={Setting.DefaultDb}");
}
if (Setting.Ssl)
{
connStr.Append($",ssl=true");
}
if (Setting.WriteBuffer != null)
{
connStr.Append($",writeBuffer={Setting.WriteBuffer}");
}
if (Setting.PoolSize != null)
{
connStr.Append($",poolsize={Setting.PoolSize}");
}
if (Setting.ConnectTimeout.Milliseconds != 5000)
{
connStr.Append($",connectTimeout={Setting.ConnectTimeout.Milliseconds}");
}
if (Setting.SyncTimeout.Milliseconds != 10000)
{
connStr.Append($",syncTimeout={Setting.SyncTimeout.Milliseconds}");
}
connStr.Append(",allowAdmin=true");
#endregion
_connectionStrs.Add(connStr.ToString());
}
}
if (string.IsNullOrEmpty(Setting.DbRange))
{
_clients.GetOrAdd(0, () => new CSRedisClient(null, _connectionStrs.ToArray()));
}
else
{
ParseDbRange(Setting.DbRange);
if (!string.IsNullOrEmpty(Setting.KeyRule))
{
ParseKeyCapture(Setting.KeyRule);
}
}
OnInitialize();
}
