public RedisErrorLoggerFeature(IRedisClientsManager redisManager)
        {
            if (redisManager == null)
                throw new ArgumentNullException("redisManager");

            this.redisManager = redisManager;
        }

 public RedisMessageHandlerWorker(
     IRedisClientsManager clientsManager, IMessageHandler messageHandler, string queueName,
     Action<IMessageHandlerBackgroundWorker, Exception> errorHandler)
     : base(messageHandler, queueName, errorHandler)
 {
     this.clientsManager = clientsManager;
 }

		public RedisQueue(
			ISerializer serializer, 
			IRedisClientsManager clientManager,
			IQueueKeyNameProvider keyNameProvider
			)
			: this(serializer, clientManager, keyNameProvider, 60)
		{ }

 public RepositoryProxy(IDbConnectionFactory dbConnectionFactory, IRedisClientsManager redisClientsManager)
 {
     DbConnectionFactory= dbConnectionFactory;
     RedisClientsManager= redisClientsManager;
     CreateCommand();
     CreateRedisClient();
 }

		private static void UseClient(IRedisClientsManager manager, int clientNo)
		{
			var cacheManager = (IRedisClientCacheManager)manager;

			var host = "";

			try
			{
				using (var client = cacheManager.GetReadOnlyCacheClient())
				{
					host = ((IRedisClient)client).Host;
					Log("Client '{0}' is using '{1}'", clientNo, host);

					var testClientKey = "test:" + host + ":" + clientNo;
					client.Set(testClientKey, testData);
					var result = client.Get<string>(testClientKey) ?? "";

					Log("\t{0} => {1} len {2} {3} len", testClientKey,
						testData.Length, testData.Length == result.Length ? "==" : "!=", result.Length);
				}
			}
			catch (NullReferenceException ex)
			{
				Log("NullReferenceException StackTrace: \n" + ex.StackTrace);
			}
			catch (Exception ex)
			{
				Log("\t[[email protected]{0}]: {1} => {2}",
					host, ex.GetType().Name, ex.Message);
			}
		}

		public RedisTransientMessageFactory(int retryAttempts, TimeSpan? requestTimeOut,
			IRedisClientsManager clientsManager)
		{
			this.ClientsManager = clientsManager ?? new BasicRedisClientManager();
			MessageService = new RedisTransientMessageService(
				retryAttempts, requestTimeOut, this);
		}

		private static void UseClientAsync(IRedisClientsManager manager, int clientNo)
		{
			using (var client = manager.GetReadOnlyClient())
			{
				UseClient(client, clientNo);
			}
		}

        public RedisCache(string regionName, IDictionary<string, string> properties, RedisCacheElement element, IRedisClientsManager clientManager)
        {
            this.serializer = new ObjectSerializer();
            this.clientManager = clientManager.ThrowIfNull("clientManager");
            RegionName = regionName.ThrowIfNull("regionName");

            expirySeconds = element != null
                ? (int)element.Expiration.TotalSeconds
                : PropertiesHelper.GetInt32(NHibernate.Cfg.Environment.CacheDefaultExpiration, properties, DefaultExpiry);

            log.DebugFormat("using expiration : {0} seconds", expirySeconds);

            var regionPrefix = PropertiesHelper.GetString(NHibernate.Cfg.Environment.CacheRegionPrefix, properties, null);
            log.DebugFormat("using region prefix : {0}", regionPrefix);

            CacheNamePrefix = element != null ? element.CachePrefix : string.Empty;

            var namespacePrefix = CacheNamePrefix + RegionName;
            if (!String.IsNullOrWhiteSpace(regionPrefix))
            {
                namespacePrefix = regionPrefix + ":" + namespacePrefix;
            }

            CacheNamespace = new RedisNamespace(namespacePrefix);
            SyncGeneration();
        }

 public static string RegisterLuaScript(IRedisClientsManager clientManager)
 {
     using (var client = clientManager.GetClient())
     {
         string scriptSha1 = client.LoadLuaScript(GetLuaScript());
         return scriptSha1;
     }
 }

        private readonly IRedisClientsManager clientsManager; //Thread safe redis client/conn factory

        public RedisQueueHandlerWorker(IRedisClientsManager clientsManager, RedisMqServer mqServer, string queueName, Action<IQueueHandlerBackgroundWorker, Exception> errorHandler) 
            : base(queueName, errorHandler)
        {            
            if (clientsManager == null) throw new ArgumentNullException("clientsManager");
            if (mqServer == null) throw new ArgumentNullException("mqServer");
            this.clientsManager = clientsManager;
            this.MqServer = mqServer;
        }

        public AudioAlarmRedisRepository(IKeyGenerator<Guid> keygenerator, IRedisClientsManager manager)
        {
            if (keygenerator == null) throw new ArgumentNullException(nameof(keygenerator));
            if (manager == null) throw new ArgumentNullException(nameof(manager));

            this.keygenerator = keygenerator;
            this.manager = manager;
        }

 public static void SetClientManager(IRedisClientsManager clientManager)
 {
     if (clientManagerStatic != null)
     {
         throw new InvalidOperationException("Redis Client Manager只能配置一次.");
     }
     clientManagerStatic = clientManager.ThrowIfNull();
 }

 public MessageHandlerWorker(
     IRedisClientsManager clientsManager, IMessageHandler messageHandler, string queueName,
     Action<MessageHandlerWorker, Exception> errorHandler)
 {
     this.clientsManager = clientsManager;
     this.messageHandler = messageHandler;
     this.QueueName = queueName;
     this.errorHandler = errorHandler;
 }

		/// <summary>
		/// Sets the client manager to be used for the session state provider. 
		/// This client manager's lifetime will not be managed by the RedisSessionStateProvider.
		/// However, if this is not set, a client manager will be created and
		/// managed by the RedisSessionStateProvider.
		/// </summary>
		/// <param name="clientManager"></param>
		public static void SetClientManager(IRedisClientsManager clientManager)
		{
			if (clientManager == null) throw new ArgumentNullException();
			if (clientManagerStatic != null)
			{
				throw new InvalidOperationException("The client manager can only be configured once.");
			}
			clientManagerStatic = clientManager;
		}

 /// <summary>
 /// Constructor
 /// </summary>
 public IdGeneratorSvc(IRedisClientsManager redisManager,
     IConfigurationSvc configurationSvc,
     ILoggerFactory loggerFactory)
 {
     this.redisManager = redisManager;
     logger = loggerFactory.GetLogger(GetType());
     idKeyPrefix = configurationSvc.GetStringConfig("IdGenerator:$Internal$:KeyPrefix", "BHS:IdGenKey:");
     idKeyPrefix = StringUtils.MustEndWith(idKeyPrefix, ":");
     logger.Info("Using " + idKeyPrefix + " as prefix for id generation keys in Redis");
 }

        public RateLimitFeatureTests()
        {
            redisManager = A.Fake<IRedisClientsManager>();
            limitProvider = A.Fake<ILimitProvider>();
            keyGenerator = A.Fake<ILimitKeyGenerator>();

            var fixture = new Fixture().Customize(new AutoFakeItEasyCustomization());
            limit = fixture.Create<Limits>();
            A.CallTo(() => limitProvider.GetLimits(A<IRequest>.Ignored)).Returns(limit);
        }

		public QueueManager(
			ISerializer serializer, 
			IRedisClientsManager clientManager, 
			IQueueKeyNameProvider keyNameProvider)
		{
			_serializer = serializer;
			_clientManager = clientManager;
			_keyNameProvider = keyNameProvider;
			_log = log4net.LogManager.GetLogger(typeof(QueueManager));
		}

 /// <summary>
 /// Constructor
 /// </summary>
 public ConfigurationSvc(IRedisClientsManager redisManager,
     ILoggerFactory loggerFactory)
     : base(loggerFactory)
 {
     this.redisManager = redisManager;
     string tmp = ConfigurationManager.AppSettings["BHSConfigKeyPrefix"];
     configKeyPrefix = (!string.IsNullOrEmpty(tmp)) ? tmp : "BHS:ConfigKey:";
     configKeyPrefix = StringUtils.MustEndWith(configKeyPrefix, ":");
     logger.Info("Using " + configKeyPrefix + " as prefix for configuration keys in Redis");
 }

        /// <summary>
        ///
        /// </summary>
        /// <param name="keygenerator"></param>
        /// <param name="eventrepository"></param>
        /// <param name="manager"></param>
        public CalendarRedisRepository(IKeyGenerator<Guid> keygenerator, IEventRepository eventrepository, IRedisClientsManager manager)
        {
            if (keygenerator == null) throw new ArgumentNullException(nameof(keygenerator));
            this.keygenerator = keygenerator;

            if (eventrepository == null) throw new ArgumentNullException(nameof(eventrepository));
            this.eventrepository = eventrepository;

            if (manager == null) throw new ArgumentNullException(nameof(manager));
            this.manager = manager;
        }

        public RedisPubSubServer(IRedisClientsManager clientsManager, params string[] channels)
        {
            this.ClientsManager = clientsManager;
            this.Channels = channels;

            var failoverHost = clientsManager as IRedisFailover;
            if (failoverHost != null)
            {
                failoverHost.OnFailover.Add(HandleFailover);
            }
        }