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); }