public RedisClient(IAppSettings appSettings, RedisConfig redisConfig, IConnectionMultiplexer redis)
{
_appSettings = appSettings;
_redisConfig = redisConfig;
_redis = redis;
_database = _redis.GetDatabase();
}
public void Dispose()
{
DisposePool();
Pool = null;
RedisConfig.Reset();
GC.SuppressFinalize(this);
}
public override void Start()
{
var subjectIDs = new List <int>();
var studentIDs = new List <long>();
var redisConfig = new RedisConfig()
{
Host = host,
Port = port,
Password = password
};
DisplayMessage(DateTime.Now.ToLongTimeString());
Action Subjects = () =>
{
var list = DataProviderService.Instance.GetSubjects();
subjectIDs = list.Select(q => q.ID).ToList();
RedisRowHelper <Subject> .CreateInstance(redisConfig).Save(list);
DisplayMessage(string.Format("Save Subjects success."));
};
Subjects();
DisplayMessage(DateTime.Now.ToLongTimeString());
Action Teachers = () =>
{
var list = DataProviderService.Instance.GetTeachers(50000);
RedisRowHelper <Teacher> .CreateInstance(redisConfig).Save(list);
DisplayMessage(string.Format("Save Subjects success."));
};
Teachers();
DisplayMessage(DateTime.Now.ToLongTimeString());
Action Students = () =>
{
var list = DataProviderService.Instance.GetStudents(100000);
studentIDs = list.Select(q => q.ID).ToList();
RedisRowHelper <Student> .CreateInstance(redisConfig).Save(list);
DisplayMessage(string.Format("Save Subjects success."));
};
Students();
DisplayMessage(DateTime.Now.ToLongTimeString());
Action StudentScores = () =>
{
var list = DataProviderService.Instance.GetStudentScores(subjectIDs, studentIDs);
RedisRowHelper <StudentScore> .CreateInstance(redisConfig).Save(list);
DisplayMessage(string.Format("Save Subjects success."));
};
StudentScores();
DisplayMessage(DateTime.Now.ToLongTimeString());
}
/// <summary>
/// 获取Redis的IDatabase
/// </summary>
/// <param name="db">存储库位置</param>
/// <param name="redisServer">连接串配置[枚举表示]</param>
/// <returns></returns>
public static IDatabase GetDB(int db = -1, DictRedisServer redisServer = DictRedisServer.RedisHost)
{
var redisServerKey = DictRedisServer.RedisHost.ToString();
if (!_creaters.TryGetValue(redisServerKey, out ConnectionMultiplexer con) || !con.IsConnected)
{
lock (_locker)
{
if (!_creaters.TryGetValue(redisServerKey, out con) || !con.IsConnected)
{
try
{
con = ConnectionMultiplexer.Connect(RedisConfig.GetRedisServer(redisServerKey));
con.ConnectionFailed += MuxerConnectionFailed;
con.ConnectionRestored += MuxerConnectionRestored;
con.ErrorMessage += MuxerErrorMessage;
con.ConfigurationChanged += MuxerConfigurationChanged;
con.HashSlotMoved += MuxerHashSlotMoved;
con.InternalError += MuxerInternalError;
_creaters[redisServerKey] = con;
}
catch (Exception ex)
{
//LogHelper.Error($"init-connectionMultiplexer:{DictRedisServer.YX_Manager_DataLoader_RedisHost}\r\n{ex}");
}
}
}
}
return(con?.GetDatabase(db));
}
public void SetConfig()
{
redisIdOptions = new RedisIdOptions();
redisIdOptions.DefaultDatabase = 10;
redisIdOptions.IdKeyPrefix = "DistributedId_";
redisIdOptions.RedisConfigList = new List <RedisConfig>();
var redisConfig1 = new RedisConfig();
redisConfig1.Host = "127.0.0.1";
redisConfig1.Port = 6379;
redisIdOptions.RedisConfigList.Add(redisConfig1);
/*
* var redisConfig2 = new RedisConfig();
* redisConfig2.Host = "192.168.1.123";
* redisConfig2.Port = 6379;
* redisConfig2.Password = "******";
* redisIdOptions.RedisConfigList.Add(redisConfig2);
*/
var redisConfig3 = new RedisConfig();
redisConfig3.Host = "127.0.0.1";
redisConfig3.Port = 6378;
redisIdOptions.RedisConfigList.Add(redisConfig3);
}
private void btn_test_redis_conn_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(this.txt_redis_pwd.Text))
{
MessageBox.Show("密码不能为空！");
return;
}
var redisConfig = new RedisConfig
{
IpAddress = this.txt_redis_ip_address.Text.Trim(),
Port = int.Parse(this.txt_redis_port.Text.Trim()),
Pwd = this.txt_redis_pwd.Text,
};
redisConfig.WhichDb = int.Parse(this.comboBox_RedisDbList.SelectedValue.ToString());
RedisConfig.WriteConfig(redisConfig);
//加载redis client
string msg = string.Empty;
if (RedisConfig.IsValidConfig)
{
msg = "Redis 测试连接成功！";
}
else
{
msg = "Redis 测试连接 失败了！！！！";
}
this.richTextBox_LogInfo.AppendText(Environment.NewLine);
this.richTextBox_LogInfo.AppendText(msg);
return;
}
/// <summary>
/// Create a new RedisAccess instance.
/// </summary>
/// <param name="connectorConfig"></param>
public RedisAccess(RedisConfig connectorConfig)
{
var conn = ConfigurationOptions.Parse(connectorConfig.ConnectionString);
conn.AllowAdmin = true;
_connection = new Lazy <ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(conn));
}
public async Task Does_Timeout_with_repeated_SocketException()
{
RedisConfig.Reset();
RedisConfig.DefaultRetryTimeout = 100;
var redis = new RedisClient(RedisConfig.DefaultHost).ForAsyncOnly();
await redis.FlushAllAsync();
Assert.That(await redis.IncrementValueAsync("retryCounter"), Is.EqualTo(1));
((RedisClient)redis).OnBeforeFlush = () =>
{
throw new SocketException();
};
try
{
await redis.IncrementValueAsync("retryCounter");
Assert.Fail("Should throw");
}
catch (RedisException ex)
{
Assert.That(ex.Message, Does.StartWith("Exceeded timeout"));
((RedisClient)redis).OnBeforeFlush = null;
Assert.That(await redis.GetAsync <int>("retryCounter"), Is.EqualTo(1));
Assert.That(RedisStats.TotalRetryCount, Is.GreaterThan(1));
Assert.That(RedisStats.TotalRetrySuccess, Is.EqualTo(0));
Assert.That(RedisStats.TotalRetryTimedout, Is.EqualTo(1));
}
RedisConfig.Reset();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
RedisConfig.RegisterRedis();
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();
var allAssemblies = new List <Assembly> {
typeof(IMediator).GetTypeInfo().Assembly, typeof(HomeController).GetTypeInfo().Assembly
};
container.RegisterSingleton <IMediator, Mediator>();
container.Register(typeof(IRequestHandler <,>), allAssemblies);
container.Register(typeof(IRequestHandler <>), allAssemblies);
container.Collection.Register(typeof(INotificationHandler <>), allAssemblies);
container.RegisterInstance(new SingleInstanceFactory(container.GetInstance));
container.RegisterInstance(new MultiInstanceFactory(container.GetAllInstances));
container.Collection.Register(typeof(IPipelineBehavior <,>), new[] { typeof(DefaultNoOpPipelineBehavior <,>) });
container.RegisterDecorator(typeof(IRequestHandler <,>), typeof(CacheRequestDecorator <,>));
container.Verify();
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
}
public ActionResult AddKey(string key, string val, string addType, int ticks)
{
DoRedisStringCache _cache = new DoRedisStringCache();
RedisConfig config = new RedisConfig();
_cache.StringSet(config.Connection, config.PrefixKey);
if (addType.Equals("1"))
{
_cache.StringSet(key, val, new TimeSpan(1, 0, 0));
_cacheHelper.Insert("Autowired_" + key, val, 5);
}
else
{
var list = GetGroupList();
// _cache.StringSetAsync<List<GroupEntity>>(key, list);
_cache.StringSet(key, list, new TimeSpan(1, 0, 0));
}
return(RedirectToAction("Index"));
}
static void Test()
{
Console.WriteLine("Wenli.Drive.Redis 批量操作实例");
var redisConfig = new RedisConfig()
{
SectionName = "Instance",
Type = RedisConnectType.Instance,
Masters = "127.0.0.1:6379",
Slaves = "127.0.0.1:6380",
Password = "******",
DefaultDatabase = 0,
BusyRetryWaitMS = 1000
};
var redisHelper = RedisHelperBuilder.Build(redisConfig);
using (var redisBatcher = redisHelper.GetRedisOperation().CreateBatcher())
{
for (int i = 0; i < 100; i++)
{
redisBatcher.Batch.StringSetAsync($"batch_{i}", $"val_{i}");
}
}
Console.Read();
}
public static void Test()
{
List<RedisConfig> ls = LocalDB<RedisConfig>.Select();
if (ls.Exists(c => c.IsClient))
{
ClientConfig = ls.First(c => c.IsClient);
}
else
{
ClientConfig = new RedisConfig("", "127.0.0.1:6379|", isClient: true);
LocalDB<RedisConfig>.Insert(ClientConfig);
}
if (ls.Exists(c => !c.IsClient))
{
ServerConfig = ls.First(c => !c.IsClient);
}
else
{
ServerConfig = new RedisConfig(@"C:\Program Files\Redis 2.4.5\64bit", "", 0, 0, 0);
LocalDB<RedisConfig>.Insert(ServerConfig);
}
ServerConfig.OpenService();
PooledRedisClientManager cm = ClientConfig.GetClientManager();
IRedisClient client = cm.GetClient();
client.Set("key1", "fasld;asdf");
var res = client.GetValue("key1");
}
/// <summary>
///
/// </summary>
/// <param name="redisConfig"></param>
public static void InitializeConfiguration(RedisConfig redisConfig)
{
int port, poolsize, database;
string ip, pass;
port = redisConfig.Port;
poolsize = redisConfig.PoolSize;
database = redisConfig.DataBase;
ip = redisConfig.Ip;
pass = redisConfig.Password;
Name = redisConfig.Name;
Instance = new ConnectionPool(ip, port, poolsize);
Instance.Connected += (s, o) => {
RedisClient rc = s as RedisClient;
if (!string.IsNullOrEmpty(pass))
{
rc.Auth(pass);
}
if (database > 0)
{
rc.Select(database);
}
};
SetCacheFileKeyPre(redisConfig.OverTimeCacheKeyPre);
SetCacheFileKeys(redisConfig.OverTimeCacheKeys);
}
public void GetTest()
{
ConfigContext _configContext = new ConfigContext();
DaoConfig _daoConfig = CachedConfigContext.Instance.Get <DaoConfig>();
string _expect = @"Data Source=YANZHIWEI-IT-PC\SQLEXPRESS;Initial Catalog=GMSLog;Persist Security Info=True;User ID=sa;Password=sasa";
Assert.AreEqual(_expect, _daoConfig.Log);
RedisConfig _actualRedisConfig = CachedConfigContext.Instance.Get <RedisConfig>();
RedisConfig _expectRedisConfig = new RedisConfig();
_expectRedisConfig.AutoStart = true;
_expectRedisConfig.LocalCacheTime = 180;
_expectRedisConfig.MaxReadPoolSize = 36;
_expectRedisConfig.MaxWritePoolSize = 36;
_expectRedisConfig.ReadServerList = "127.0.0.1:6379";
_expectRedisConfig.WriteServerList = "127.0.0.1:6379";
Assert.AreEqual(_expectRedisConfig.ReadServerList, _actualRedisConfig.ReadServerList);
Assert.AreEqual(_expectRedisConfig.WriteServerList, _actualRedisConfig.WriteServerList);
Assert.AreEqual(_expectRedisConfig.LocalCacheTime, _actualRedisConfig.LocalCacheTime);
//_configContext.Save(_redisConfig);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var configurationBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("config.json");
var config = configurationBuilder.Build();
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterControllers(Assembly.GetExecutingAssembly());
containerBuilder.Register(context => config).As <IConfiguration>().InstancePerLifetimeScope();
containerBuilder.Register(a =>
{
var redisConfig = new RedisConfig();
a.Resolve <IConfiguration>().GetSection("Redis").Bind(redisConfig);
return(redisConfig);
}).InstancePerLifetimeScope();
var container = containerBuilder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
public void Does_not_retry_when_RetryTimeout_is_Zero()
{
RedisConfig.Reset();
RedisConfig.DefaultRetryTimeout = 0;
var redis = new RedisClient(Config.MasterHost);
redis.FlushAll();
Assert.That(redis.IncrementValue("retryCounter"), Is.EqualTo(1));
redis.OnBeforeFlush = () => throw new SocketException();
try {
redis.IncrementValue("retryCounter");
Assert.Fail("Should throw");
} catch (Exception ex) {
Assert.That(ex.Message, Does.StartWith("Exceeded timeout"));
redis.OnBeforeFlush = null;
Assert.That(redis.Get <int>("retryCounter"), Is.EqualTo(1));
Assert.That(RedisStats.TotalRetryCount, Is.EqualTo(0));
Assert.That(RedisStats.TotalRetrySuccess, Is.EqualTo(0));
Assert.That(RedisStats.TotalRetryTimedout, Is.EqualTo(1));
}
RedisConfig.Reset();
}
/// <summary>
/// Initializes a new instance of the <see cref="PoolConfig"/> class.
/// </summary>
/// <param name="config">The configuration.</param>
/// <param name="coinConfig"></param>
public PoolConfig(dynamic config, ICoinConfig coinConfig)
{
try
{
Enabled = config.enabled ? config.enabled : false;
if (Enabled == false) // if the configuration is not enabled
{
return; // just skip reading rest of the parameters.
}
Coin = coinConfig; // assign the coin config.
// load the sections.
Daemon = new DaemonConfig(config.daemon);
Meta = new MetaConfig(config.meta);
Wallet = new WalletConfig(config.wallet);
Rewards = new RewardsConfig(config.rewards);
Payments = new PaymentConfig(config.payments);
Miner = new MinerConfig(config.miner);
Job = new JobConfig(config.job);
Stratum = new StratumServerConfig(config.stratum);
Banning = new BanConfig(config.banning);
Storage = new RedisConfig(config.storage.redis);
Vanilla = new VanillaServerConfig(config.vanilla);
Valid = true;
}
catch (Exception e)
{
Valid = false;
Log.Logger.ForContext <PoolConfig>().Error(e, "Error loading pool configuration");
}
}
static void Main(string[] args)
{
//示例：根据特性验证
UserInfo user = new UserInfo();
user.name = "aaa";
user.QQ = "12345ss";
string errorMsg = string.Empty;
bool verify = user.Verity(out errorMsg);
Console.WriteLine(verify + ":" + errorMsg);
Console.WriteLine("____________________________________");
//示例：根据特性获取枚举自定义属性
EnumManager.TypeEnmu typeEnum = EnumManager.TypeEnmu.ToPay;
Console.WriteLine(typeEnum.getTypeName());
Console.WriteLine("____________________________________");
RedisConfig redisConfig = new RedisConfig();
redisConfig.MasterHostAndPort = "10.24.38.224:6379";
redisConfig.Password = "******";
redisConfig.SlaveHostsAndPorts = "10.24.38.224:6380,";
redisConfig.StringSeperator = ",";
//ConsoleTest.Model.Configuration.Redis.RedisConfig
string type = redisConfig.GetType().ToString();
//Console.WriteLine(redisConfig.GetType().ToString());
redisConfig.GetType().GetProperties().ToList().ForEach(delegate(PropertyInfo property) {
ZzhKeyAttribute key1 = property.GetCustomAttribute(typeof(ZzhKeyAttribute)) as ZzhKeyAttribute;
string value = property.GetValue(redisConfig).ToString();
Console.WriteLine(key1.Key + "：" + value);
Console.WriteLine(key1.Key2);
});
Console.ReadKey();
}
public void Does_Timeout_with_repeated_SocketException()
{
RedisConfig.Reset();
RedisConfig.DefaultRetryTimeout = 100;
var redis = new RedisClient(RedisConfig.DefaultHost);
redis.FlushAll();
Assert.That(redis.IncrementValue("retryCounter"), Is.EqualTo(1));
redis.OnBeforeFlush = () =>
{
throw new SocketException();
};
try
{
redis.IncrementValue("retryCounter");
Assert.Fail("Should throw");
}
catch (RedisException ex)
{
Assert.That(ex.Message, Is.StringStarting("Exceeded timeout"));
redis.OnBeforeFlush = null;
Assert.That(redis.Get <int>("retryCounter"), Is.EqualTo(1));
Assert.That(RedisStats.TotalRetryCount, Is.GreaterThan(1));
Assert.That(RedisStats.TotalRetrySuccess, Is.EqualTo(0));
Assert.That(RedisStats.TotalRetryTimedout, Is.EqualTo(1));
}
RedisConfig.Reset();
}
private void Form_Redis_Load(object sender, EventArgs e)
{
var lst_db = new List <object>();
for (int i = 0; i < 15; i++)
{
lst_db.Add(new { Id = i, Text = i });
//var item=new selectit
}
this.comboBox_RedisDbList.DataSource = lst_db;
this.comboBox_RedisDbList.ValueMember = "Id";
this.comboBox_RedisDbList.DisplayMember = "Text";
var redisConfig = RedisConfig.LoadConfig();
if (null != redisConfig)
{
this.txt_redis_ip_address.Text = redisConfig.IpAddress;
this.txt_redis_port.Text = redisConfig.Port.ToString();
this.txt_redis_pwd.Text = redisConfig.Pwd;
this.comboBox_RedisDbList.SelectedValue = redisConfig.WhichDb;
}
else
{
this.comboBox_RedisDbList.SelectedIndex = 0;
}
//订阅发送cookie到远程的事件
CrawlerCookiesPopJob.OnSendCookiesToRemoteEvent -= Handler_OnSendCookiesToRemoteEvent;
CrawlerCookiesPopJob.OnSendCookiesToRemoteEvent += Handler_OnSendCookiesToRemoteEvent;
}
/// <summary>
/// 缓存Key
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual string GetKey(string id)
{
if (!_cacheOpen)
{
return("");
}
return(RedisConfig.GetKey(ClsName, "item", id));
}
/// <summary>
/// 加载Redis服务
/// </summary>
/// <param name="services"></param>
/// <param name="action"></param>
public static IServiceCollection AddRedis(this IServiceCollection services,
Action <RedisConfig> action)
{
RedisConfig redisConfig = new RedisConfig();
action.Invoke(redisConfig);
return(services.AddRedis(() => redisConfig));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
RedisProxyAgent.redisConfig = RedisConfig.GetConfig();
}
public RedisConnector(RedisConfig redisConfig)
{
this._redisConfig = redisConfig;
this._lazyConnection = new Lazy <ConnectionMultiplexer>(() =>
{
return(ConnectionMultiplexer.Connect(GetConnectionString()));
});
}
/// <summary>
///
/// </summary>
public RedisCacheService(RedisConfig redisConfig, ICollection <IJsonProvider> jsonProviders)
{
_jsonProvider = InjectionSelectionCommon.GetImplement(jsonProviders);
ValidationCommon.Check(redisConfig, "redis配置异常", HttpStatus.Err.Name);
new RedisConfigValidator().Validate(redisConfig).Check();
_prefix = redisConfig.Name;
CsRedisHelper.InitializeConfiguration(redisConfig);
}
public MultiTenantPlatformDbContext() : base(ConnectionStringsConfig.Get("MultiTenantPlatformWeb"))
{
//开启一级缓存
OpenQueryCache = false;
//用redis做缓存
CacheMediaType = Bantina.Bankinate.Cache.CacheMediaType.Local;
CacheMediaServer = $"{RedisConfig.Get("101", "Server")}:{RedisConfig.Get("101", "Port")}";//redis服务器地址以及端口号
}
public StackExchangeRedisClient(RedisConfig redisConfig, IRedisBinarySerializer serializer)
{
EnsureUtil.NotNull(redisConfig, "redisConfig");
EnsureUtil.NotNull(serializer, "serializer");
_redisConfig = redisConfig;
_serializer = serializer;
_database = ConnectionMultiplexerFactory.GetDatabase(_redisConfig);
_connectionMultiplexer = ConnectionMultiplexerFactory.GetConnectionMultiplexer(_redisConfig);
}
/// <summary>
/// Creates a RedisRepo configuration object (RedisRepo.RedisConfig) based on the current site environment
/// </summary>
/// <returns>RedisConfig type from the RedisRepo library</returns>
public static RedisConfig GetRedisConfig()
{
//\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
// -- This method returns a singleton RedisConfig object \\
// -- The RedisConfig type is an object that holds the metadata for connecting to a Redis server through \\
// the StackExchange.Redis library. \\
// -- It should be a singleton in your application because the StackExchange.Redis library manages your \\
// connection to the Redis server and that connection itself is a singleton. \\
// -- This means that if you were to create a new RedisConfig object everytime you needed to access the \\
// Redis server, you would eventually run out of connections available to the Redis Server, thus \\
// freezing your application or making it come to a crawl. \\
//\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
// Check to see if we already created a RedisConfig object and return it if we did.
if (_redisConfig != null)
{
return(_redisConfig);
}
// Set the Redis database we want to connect to inside of the Redis Server. This is a logical database with no security boundaries
var redisDatabase = -1;
switch (AppConst.SiteEnvironment)
{
case "Local":
redisDatabase = 1;
break;
case "Dev":
redisDatabase = 0;
break;
case "Production":
redisDatabase = 1;
break;
case "QA":
redisDatabase = 3;
break;
case "Test":
redisDatabase = 10;
break;
case "Staging":
redisDatabase = 2;
break;
default:
redisDatabase = 0;
break;
}
// Set the RedisConfig object singleton and return it
_redisConfig = new RedisConfig(AppConst.RedisConnectionString, redisDatabase);
return(_redisConfig);
}
public GetModelKeyService(string host, int port, string password)
{
redisConfig = new RedisConfig()
{
Host = host,
Port = port,
Password = password
};
}
public MultiTenantPlatformDbContext() : base(ConnectionStringsConfig.Instance.MultiTenantPlatformWeb)
{
//开启一级缓存
OpenQueryCache = false;
OpenTableCache = false;
//用redis做缓存
CacheMediaType = CacheMediaType.Local;
CacheMediaServer = $"{RedisConfig.Get("101", "Server")}:{RedisConfig.Get("101", "Port")}";//redis服务器地址以及端口号
}
public RedisService(RedisConfig config, int db = 0)
{
var _config = config;
ConnectionString = string.IsNullOrEmpty(_config.Password) ?
$"{_config.Address}:{_config.Port}" : $"{_config.Address}:{_config.Port},password={_config.Password}";
_connMultiplexer = ConnectionMultiplexer.Connect(ConnectionString);
RegisterEvent();
_db = _connMultiplexer.GetDatabase(db);
}
static RedisProvider()
{
Log = LoggerProvider.LoggerFor(typeof (RedisProvider));
Config = ConfigurationManager.GetSection("redis") as RedisConfig;
if (Config == null)
{
Log.Info("redis configuration section not found, using default configuration (127.0.0.1:6379).");
Config = new RedisConfig("localhost",6379);
}
}
public void Open(RedisConfig config)
{
var serializer = new NewtonsoftSerializer();
var connectionString = config.GetRedisConfiguration();
try
{
_client = new StackExchangeRedisCacheClient(serializer, connectionString);
}
catch (Exception)
{
_client = null;
}
}
public void Open(RedisConfig config)
{
var connectionString = config.GetRedisConfiguration();
var cancellationToken = new CancellationTokenSource(TimeSpan.FromSeconds(30)).Token;
try
{
Task.Run(
() => _connection = ConnectionMultiplexer.Connect(ConfigurationOptions.Parse(connectionString)), cancellationToken).Wait(cancellationToken);
_server = _connection.GetServer(config.Host, config.Port);
}
catch (Exception)
{
_connection = null;
}
}
public RedisService()
{
Config = new RedisConfig();
var connection = new Connection();
_connectionFactory = new ConnectionFactory(connection, Config);
}
public ConnectionFactory(IConnection connection, RedisConfig redisConfig)
{
_connection = connection;
_redisConfig = redisConfig;
}
public static void Init(RedisConfig redisConfig)
{
var connection = new Connection();
ConnectionFactory = new ConnectionFactory(connection, redisConfig);
}
