使用 StackExchange.Redis 封装属于自己的 RedisHelper

目录

• 核心类 ConnectionMultiplexer
• 字符串(String)
• 哈希(Hash)
• 列表(List)
• 有序集合(sorted set)
• Key 操作
• 发布订阅
• 其他

 

简介

　　目前 .NET 使用访问 Redis 的的类库主流应该是 StackExchange.Redis，自己参考网上的文章（也许是吃饱了撑着），也尝试做出简单的封装。

/// 
    /// Redis 助手    /// 
    public class RedisHelper    {        /// 
        /// 连接字符串        /// 
        private static readonly string ConnectionString;        /// 
        /// redis 连接对象        /// 
        private static IConnectionMultiplexer _connMultiplexer;        /// 
        /// 默认的 Key 值（用来当作 RedisKey 的前缀）        /// 
        private static readonly string DefaultKey;        /// 
        /// 锁        /// 
        private static readonly object Locker = new object();        /// 
        /// 数据库        /// 
        private readonly IDatabase _db;        /// 
        /// 获取 Redis 连接对象        /// 
        /// 
              public IConnectionMultiplexer GetConnectionRedisMultiplexer()        {            if ((_connMultiplexer == null) || !_connMultiplexer.IsConnected)            {                lock (Locker)                {                    if ((_connMultiplexer == null) || !_connMultiplexer.IsConnected)                        _connMultiplexer = ConnectionMultiplexer.Connect(ConnectionString);                }            }            return _connMultiplexer;        }        #region 其它        public ITransaction GetTransaction()        {            return _db.CreateTransaction();        }        #endregion 其它        #region 构造函数        static RedisHelper()        {            ConnectionString = ConfigurationManager.ConnectionStrings["RedisConnectionString"].ConnectionString;            _connMultiplexer = ConnectionMultiplexer.Connect(ConnectionString);            DefaultKey = ConfigurationManager.AppSettings["Redis.DefaultKey"];            AddRegisterEvent();        }        public RedisHelper(int db = -1)        {            _db = _connMultiplexer.GetDatabase(db);        }        #endregion 构造函数        #region String 操作        /// 
        /// 设置 key 并保存字符串（如果 key 已存在，则覆盖值）        /// 
        ///         ///         ///         /// 
              public bool StringSet(string redisKey, string redisValue, TimeSpan? expiry = null)        {            redisKey = AddKeyPrefix(redisKey);            return _db.StringSet(redisKey, redisValue, expiry);        }        /// 
        /// 保存多个 Key-value        /// 
        ///         /// 
              public bool StringSet(IEnumerable
      
       
        > keyValuePairs)        {            keyValuePairs =                keyValuePairs.Select(x => new KeyValuePair
        
         (AddKeyPrefix(x.Key), x.Value));            return _db.StringSet(keyValuePairs.ToArray());        }        /// 
         
        /// 获取字符串        /// 
        /// 
                 /// 
                 /// 
                 public string StringGet(string redisKey, TimeSpan? expiry = null)        {            redisKey = AddKeyPrefix(redisKey);            return _db.StringGet(redisKey);        }        /// 
         
        /// 存储一个对象（该对象会被序列化保存）        /// 
        /// 
                 /// 
                 /// 
                 /// 
                 public bool StringSet
         
          (string redisKey, T redisValue, TimeSpan? expiry = null)        {            redisKey = AddKeyPrefix(redisKey);            var json = Serialize(redisValue);            return _db.StringSet(redisKey, json, expiry);        }        /// 
          
        /// 获取一个对象（会进行反序列化）        /// 
        /// 
                  /// 
                  /// 
                  public T StringGet
          
           (string redisKey, TimeSpan? expiry = null)        {            redisKey = AddKeyPrefix(redisKey);            return Deserialize
           
            (_db.StringGet(redisKey)); } #region async /// 
            
 /// 保存一个字符串值 /// 
 /// 
             /// 
             /// 
             /// 
             public async Task
            
              StringSetAsync(string redisKey, string redisValue, TimeSpan? expiry = null) { redisKey = AddKeyPrefix(redisKey); return await _db.StringSetAsync(redisKey, redisValue, expiry); } /// 
             
 /// 保存一组字符串值 /// 
 /// 
              /// 
              public async Task
             
               StringSetAsync(IEnumerable
              
               
                > keyValuePairs) { keyValuePairs = keyValuePairs.Select(x => new KeyValuePair
                
                 (AddKeyPrefix(x.Key), x.Value)); return await _db.StringSetAsync(keyValuePairs.ToArray()); } /// 
                 
 /// 获取单个值 /// 
 /// 
                  /// 
                  /// 
                  /// 
                  public async Task
                 
                   StringGetAsync(string redisKey, string redisValue, TimeSpan? expiry = null) { redisKey = AddKeyPrefix(redisKey); return await _db.StringGetAsync(redisKey); } /// 
                  
 /// 存储一个对象（该对象会被序列化保存） /// 
 /// 
                   /// 
                   /// 
                   /// 
                   public async Task
                  
                    StringSetAsync
                   
                    (string redisKey, T redisValue, TimeSpan? expiry = null) { redisKey = AddKeyPrefix(redisKey); var json = Serialize(redisValue); return await _db.StringSetAsync(redisKey, json, expiry); } /// 
                    
 /// 获取一个对象（会进行反序列化） /// 
 /// 
                     /// 
                     /// 
                     public async Task
                    
                      StringGetAsync
                     
                      (string redisKey, TimeSpan? expiry = null) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                      
                       (await _db.StringGetAsync(redisKey)); } #endregion async #endregion String 操作 #region Hash 操作 /// 
                       
 /// 判断该字段是否存在 hash 中 /// 
 /// 
                        /// 
                        /// 
                        public bool HashExists(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return _db.HashExists(redisKey, hashField); } /// 
                       
 /// 从 hash 中移除指定字段 /// 
 /// 
                        /// 
                        /// 
                        public bool HashDelete(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return _db.HashDelete(redisKey, hashField); } /// 
                       
 /// 从 hash 中移除指定字段 /// 
 /// 
                        /// 
                        /// 
                        public long HashDelete(string redisKey, IEnumerable
                       
                         hashField) { redisKey = AddKeyPrefix(redisKey); return _db.HashDelete(redisKey, hashField.ToArray()); } /// 
                        
 /// 在 hash 设定值 /// 
 /// 
                         /// 
                         /// 
                         /// 
                         public bool HashSet(string redisKey, string hashField, string value) { redisKey = AddKeyPrefix(redisKey); return _db.HashSet(redisKey, hashField, value); } /// 
                        
 /// 在 hash 中设定值 /// 
 /// 
                         /// 
                         public void HashSet(string redisKey, IEnumerable
                        
                          hashFields) { redisKey = AddKeyPrefix(redisKey); _db.HashSet(redisKey, hashFields.ToArray()); } /// 
                         
 /// 在 hash 中获取值 /// 
 /// 
                          /// 
                          /// 
                          public RedisValue HashGet(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return _db.HashGet(redisKey, hashField); } /// 
                         
 /// 在 hash 中获取值 /// 
 /// 
                          /// 
                          /// 
                          /// 
                          public RedisValue[] HashGet(string redisKey, RedisValue[] hashField, string value) { redisKey = AddKeyPrefix(redisKey); return _db.HashGet(redisKey, hashField); } /// 
                         
 /// 从 hash 返回所有的字段值 /// 
 /// 
                          /// 
                          public IEnumerable
                         
                           HashKeys(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.HashKeys(redisKey); } /// 
                          
 /// 返回 hash 中的所有值 /// 
 /// 
                           /// 
                           public RedisValue[] HashValues(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.HashValues(redisKey); } /// 
                          
 /// 在 hash 设定值（序列化） /// 
 /// 
                           /// 
                           /// 
                           /// 
                           public bool HashSet
                          
                           (string redisKey, string hashField, T value) { redisKey = AddKeyPrefix(redisKey); var json = Serialize(value); return _db.HashSet(redisKey, hashField, json); } /// 
                           
 /// 在 hash 中获取值（反序列化） /// 
 /// 
                            /// 
                            /// 
                            public T HashGet
                           
                            (string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                            
                             (_db.HashGet(redisKey, hashField)); } #region async /// 
                             
 /// 判断该字段是否存在 hash 中 /// 
 /// 
                              /// 
                              /// 
                              public async Task
                             
                               HashExistsAsync(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return await _db.HashExistsAsync(redisKey, hashField); } /// 
                              
 /// 从 hash 中移除指定字段 /// 
 /// 
                               /// 
                               /// 
                               public async Task
                              
                                HashDeleteAsync(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return await _db.HashDeleteAsync(redisKey, hashField); } /// 
                               
 /// 从 hash 中移除指定字段 /// 
 /// 
                                /// 
                                /// 
                                public async Task
                               
                                 HashDeleteAsync(string redisKey, IEnumerable
                                
                                  hashField) { redisKey = AddKeyPrefix(redisKey); return await _db.HashDeleteAsync(redisKey, hashField.ToArray()); } /// 
                                 
 /// 在 hash 设定值 /// 
 /// 
                                  /// 
                                  /// 
                                  /// 
                                  public async Task
                                 
                                   HashSetAsync(string redisKey, string hashField, string value) { redisKey = AddKeyPrefix(redisKey); return await _db.HashSetAsync(redisKey, hashField, value); } /// 
                                  
 /// 在 hash 中设定值 /// 
 /// 
                                   /// 
                                   public async Task HashSetAsync(string redisKey, IEnumerable
                                  
                                    hashFields) { redisKey = AddKeyPrefix(redisKey); await _db.HashSetAsync(redisKey, hashFields.ToArray()); } /// 
                                   
 /// 在 hash 中获取值 /// 
 /// 
                                    /// 
                                    /// 
                                    public async Task
                                   
                                     HashGetAsync(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return await _db.HashGetAsync(redisKey, hashField); } /// 
                                    
 /// 在 hash 中获取值 /// 
 /// 
                                     /// 
                                     /// 
                                     /// 
                                     public async Task
                                    
                                     
                                      > HashGetAsync(string redisKey, RedisValue[] hashField, string value) { redisKey = AddKeyPrefix(redisKey); return await _db.HashGetAsync(redisKey, hashField); } /// 
                                      
 /// 从 hash 返回所有的字段值 /// 
 /// 
                                       /// 
                                       public async Task
                                      
                                       
                                        > HashKeysAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.HashKeysAsync(redisKey); } /// 
                                        
 /// 返回 hash 中的所有值 /// 
 /// 
                                         /// 
                                         public async Task
                                        
                                         
                                          > HashValuesAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.HashValuesAsync(redisKey); } /// 
                                          
 /// 在 hash 设定值（序列化） /// 
 /// 
                                           /// 
                                           /// 
                                           /// 
                                           public async Task
                                          
                                            HashSetAsync
                                           
                                            (string redisKey, string hashField, T value) { redisKey = AddKeyPrefix(redisKey); var json = Serialize(value); return await _db.HashSetAsync(redisKey, hashField, json); } /// 
                                            
 /// 在 hash 中获取值（反序列化） /// 
 /// 
                                             /// 
                                             /// 
                                             public async Task
                                            
                                              HashGetAsync
                                             
                                              (string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                                              
                                               (await _db.HashGetAsync(redisKey, hashField)); } #endregion async #endregion Hash 操作 #region List 操作 /// 
                                               
 /// 移除并返回存储在该键列表的第一个元素 /// 
 /// 
                                                /// 
                                                public string ListLeftPop(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.ListLeftPop(redisKey); } /// 
                                               
 /// 移除并返回存储在该键列表的最后一个元素 /// 
 /// 
                                                /// 
                                                public string ListRightPop(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.ListRightPop(redisKey); } /// 
                                               
 /// 移除列表指定键上与该值相同的元素 /// 
 /// 
                                                /// 
                                                /// 
                                                public long ListRemove(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return _db.ListRemove(redisKey, redisValue); } /// 
                                               
 /// 在列表尾部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                                                /// 
                                                /// 
                                                public long ListRightPush(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return _db.ListRightPush(redisKey, redisValue); } /// 
                                               
 /// 在列表头部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                                                /// 
                                                /// 
                                                public long ListLeftPush(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return _db.ListLeftPush(redisKey, redisValue); } /// 
                                               
 /// 返回列表上该键的长度，如果不存在，返回 0 /// 
 /// 
                                                /// 
                                                public long ListLength(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.ListLength(redisKey); } /// 
                                               
 /// 返回在该列表上键所对应的元素 /// 
 /// 
                                                /// 
                                                public IEnumerable
                                               
                                                 ListRange(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.ListRange(redisKey); } /// 
                                                
 /// 移除并返回存储在该键列表的第一个元素 /// 
 /// 
                                                 /// 
                                                 public T ListLeftPop
                                                
                                                 (string redisKey) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                                                 
                                                  (_db.ListLeftPop(redisKey)); } /// 
                                                  
 /// 移除并返回存储在该键列表的最后一个元素 /// 
 /// 
                                                   /// 
                                                   public T ListRightPop
                                                  
                                                   (string redisKey) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                                                   
                                                    (_db.ListRightPop(redisKey)); } /// 
                                                    
 /// 在列表尾部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                                                     /// 
                                                     /// 
                                                     public long ListRightPush
                                                    
                                                     (string redisKey, T redisValue) { redisKey = AddKeyPrefix(redisKey); return _db.ListRightPush(redisKey, Serialize(redisValue)); } /// 
                                                     
 /// 在列表头部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                                                      /// 
                                                      /// 
                                                      public long ListLeftPush
                                                     
                                                      (string redisKey, T redisValue) { redisKey = AddKeyPrefix(redisKey); return _db.ListLeftPush(redisKey, Serialize(redisValue)); } #region List-async /// 
                                                      
 /// 移除并返回存储在该键列表的第一个元素 /// 
 /// 
                                                       /// 
                                                       public async Task
                                                      
                                                        ListLeftPopAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.ListLeftPopAsync(redisKey); } /// 
                                                       
 /// 移除并返回存储在该键列表的最后一个元素 /// 
 /// 
                                                        /// 
                                                        public async Task
                                                       
                                                         ListRightPopAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRightPopAsync(redisKey); } /// 
                                                        
 /// 移除列表指定键上与该值相同的元素 /// 
 /// 
                                                         /// 
                                                         /// 
                                                         public async Task
                                                        
                                                          ListRemoveAsync(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRemoveAsync(redisKey, redisValue); } /// 
                                                         
 /// 在列表尾部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                                                          /// 
                                                          /// 
                                                          public async Task
                                                         
                                                           ListRightPushAsync(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRightPushAsync(redisKey, redisValue); } /// 
                                                          
 /// 在列表头部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                                                           /// 
                                                           /// 
                                                           public async Task
                                                          
                                                            ListLeftPushAsync(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListLeftPushAsync(redisKey, redisValue); } /// 
                                                           
 /// 返回列表上该键的长度，如果不存在，返回 0 /// 
 /// 
                                                            /// 
                                                            public async Task
                                                           
                                                             ListLengthAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.ListLengthAsync(redisKey); } /// 
                                                            
 /// 返回在该列表上键所对应的元素 /// 
 /// 
                                                             /// 
                                                             public async Task
                                                            
                                                             
                                                              > ListRangeAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRangeAsync(redisKey); } /// 
                                                              
 /// 移除并返回存储在该键列表的第一个元素 /// 
 /// 
                                                               /// 
                                                               public async Task
                                                              
                                                                ListLeftPopAsync
                                                               
                                                                (string redisKey) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                                                                
                                                                 (await _db.ListLeftPopAsync(redisKey)); } /// 
                                                                 
 /// 移除并返回存储在该键列表的最后一个元素 /// 
 /// 
                                                                  /// 
                                                                  public async Task
                                                                 
                                                                   ListRightPopAsync
                                                                  
                                                                   (string redisKey) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                                                                   
                                                                    (await _db.ListRightPopAsync(redisKey)); } /// 
                                                                    
 /// 在列表尾部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                                                                     /// 
                                                                     /// 
                                                                     public async Task
                                                                    
                                                                      ListRightPushAsync
                                                                     
                                                                      (string redisKey, T redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRightPushAsync(redisKey, Serialize(redisValue)); } /// 
                                                                      
 /// 在列表头部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                                                                       /// 
                                                                       /// 
                                                                       public async Task
                                                                      
                                                                        ListLeftPushAsync
                                                                       
                                                                        (string redisKey, T redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListLeftPushAsync(redisKey, Serialize(redisValue)); } #endregion List-async #endregion List 操作 #region SortedSet 操作 /// 
                                                                        
 /// SortedSet 新增 /// 
 /// 
                                                                         /// 
                                                                         /// 
                                                                         /// 
                                                                         public bool SortedSetAdd(string redisKey, string member, double score) { redisKey = AddKeyPrefix(redisKey); return _db.SortedSetAdd(redisKey, member, score); } /// 
                                                                        
 /// 在有序集合中返回指定范围的元素，默认情况下从低到高。 /// 
 /// 
                                                                         /// 
                                                                         public IEnumerable
                                                                        
                                                                          SortedSetRangeByRank(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.SortedSetRangeByRank(redisKey); } /// 
                                                                         
 /// 返回有序集合的元素个数 /// 
 /// 
                                                                          /// 
                                                                          public long SortedSetLength(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.SortedSetLength(redisKey); } /// 
                                                                         
 /// 返回有序集合的元素个数 /// 
 /// 
                                                                          /// 
                                                                          /// 
                                                                          public bool SortedSetLength(string redisKey, string memebr) { redisKey = AddKeyPrefix(redisKey); return _db.SortedSetRemove(redisKey, memebr); } /// 
                                                                         
 /// SortedSet 新增 /// 
 /// 
                                                                          /// 
                                                                          /// 
                                                                          /// 
                                                                          public bool SortedSetAdd
                                                                         
                                                                          (string redisKey, T member, double score) { redisKey = AddKeyPrefix(redisKey); var json = Serialize(member); return _db.SortedSetAdd(redisKey, json, score); } #region SortedSet-Async /// 
                                                                          
 /// SortedSet 新增 /// 
 /// 
                                                                           /// 
                                                                           /// 
                                                                           /// 
                                                                           public async Task
                                                                          
                                                                            SortedSetAddAsync(string redisKey, string member, double score) { redisKey = AddKeyPrefix(redisKey); return await _db.SortedSetAddAsync(redisKey, member, score); } /// 
                                                                           
 /// 在有序集合中返回指定范围的元素，默认情况下从低到高。 /// 
 /// 
                                                                            /// 
                                                                            public async Task
                                                                           
                                                                            
                                                                             > SortedSetRangeByRankAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.SortedSetRangeByRankAsync(redisKey); } /// 
                                                                             
 /// 返回有序集合的元素个数 /// 
 /// 
                                                                              /// 
                                                                              public async Task
                                                                             
                                                                               SortedSetLengthAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.SortedSetLengthAsync(redisKey); } /// 
                                                                              
 /// 返回有序集合的元素个数 /// 
 /// 
                                                                               /// 
                                                                               /// 
                                                                               public async Task
                                                                              
                                                                                SortedSetRemoveAsync(string redisKey, string memebr) { redisKey = AddKeyPrefix(redisKey); return await _db.SortedSetRemoveAsync(redisKey, memebr); } /// 
                                                                               
 /// SortedSet 新增 /// 
 /// 
                                                                                /// 
                                                                                /// 
                                                                                /// 
                                                                                public async Task
                                                                               
                                                                                 SortedSetAddAsync
                                                                                
                                                                                 (string redisKey, T member, double score) { redisKey = AddKeyPrefix(redisKey); var json = Serialize(member); return await _db.SortedSetAddAsync(redisKey, json, score); } #endregion SortedSet-Async #endregion SortedSet 操作 #region key 操作 /// 
                                                                                 
 /// 移除指定 Key /// 
 /// 
                                                                                  /// 
                                                                                  public bool KeyDelete(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.KeyDelete(redisKey); } /// 
                                                                                 
 /// 移除指定 Key /// 
 /// 
                                                                                  /// 
                                                                                  public long KeyDelete(IEnumerable
                                                                                 
                                                                                   redisKeys) { var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x)); return _db.KeyDelete(keys.ToArray()); } /// 
                                                                                  
 /// 校验 Key 是否存在 /// 
 /// 
                                                                                   /// 
                                                                                   public bool KeyExists(string redisKey) { redisKey = AddKeyPrefix(redisKey); return _db.KeyExists(redisKey); } /// 
                                                                                  
 /// 重命名 Key /// 
 /// 
                                                                                   /// 
                                                                                   /// 
                                                                                   public bool KeyRename(string redisKey, string redisNewKey) { redisKey = AddKeyPrefix(redisKey); return _db.KeyRename(redisKey, redisNewKey); } /// 
                                                                                  
 /// 设置 Key 的时间 /// 
 /// 
                                                                                   /// 
                                                                                   /// 
                                                                                   public bool KeyExpire(string redisKey, TimeSpan? expiry) { redisKey = AddKeyPrefix(redisKey); return _db.KeyExpire(redisKey, expiry); } #region key-async /// 
                                                                                  
 /// 移除指定 Key /// 
 /// 
                                                                                   /// 
                                                                                   public async Task
                                                                                  
                                                                                    KeyDeleteAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.KeyDeleteAsync(redisKey); } /// 
                                                                                   
 /// 移除指定 Key /// 
 /// 
                                                                                    /// 
                                                                                    public async Task
                                                                                   
                                                                                     KeyDeleteAsync(IEnumerable
                                                                                    
                                                                                      redisKeys) { var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x)); return await _db.KeyDeleteAsync(keys.ToArray()); } /// 
                                                                                     
 /// 校验 Key 是否存在 /// 
 /// 
                                                                                      /// 
                                                                                      public async Task
                                                                                     
                                                                                       KeyExistsAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.KeyExistsAsync(redisKey); } /// 
                                                                                      
 /// 重命名 Key /// 
 /// 
                                                                                       /// 
                                                                                       /// 
                                                                                       public async Task
                                                                                      
                                                                                        KeyRenameAsync(string redisKey, string redisNewKey) { redisKey = AddKeyPrefix(redisKey); return await _db.KeyRenameAsync(redisKey, redisNewKey); } /// 
                                                                                       
 /// 设置 Key 的时间 /// 
 /// 
                                                                                        /// 
                                                                                        /// 
                                                                                        public async Task
                                                                                       
                                                                                         KeyExpireAsync(string redisKey, TimeSpan? expiry) { redisKey = AddKeyPrefix(redisKey); return await _db.KeyExpireAsync(redisKey, expiry); } #endregion key-async #endregion key 操作 #region 发布订阅 /// 
                                                                                        
 /// 订阅 /// 
 /// 
                                                                                         /// 
                                                                                         public void Subscribe(RedisChannel channel, Action
                                                                                        
                                                                                          handle) { var sub = _connMultiplexer.GetSubscriber(); sub.Subscribe(channel, handle); } /// 
                                                                                         
 /// 发布 /// 
 /// 
                                                                                          /// 
                                                                                          /// 
                                                                                          public long Publish(RedisChannel channel, RedisValue message) { var sub = _connMultiplexer.GetSubscriber(); return sub.Publish(channel, message); } /// 
                                                                                         
 /// 发布（使用序列化） /// 
 /// 
                                                                                          /// 
                                                                                          /// 
                                                                                          /// 
                                                                                          public long Publish
                                                                                         
                                                                                          (RedisChannel channel, T message) { var sub = _connMultiplexer.GetSubscriber(); return sub.Publish(channel, Serialize(message)); } #region 发布订阅-async /// 
                                                                                          
 /// 订阅 /// 
 /// 
                                                                                           /// 
                                                                                           public async Task SubscribeAsync(RedisChannel channel, Action
                                                                                          
                                                                                            handle) { var sub = _connMultiplexer.GetSubscriber(); await sub.SubscribeAsync(channel, handle); } /// 
                                                                                           
 /// 发布 /// 
 /// 
                                                                                            /// 
                                                                                            /// 
                                                                                            public async Task
                                                                                           
                                                                                             PublishAsync(RedisChannel channel, RedisValue message) { var sub = _connMultiplexer.GetSubscriber(); return await sub.PublishAsync(channel, message); } /// 
                                                                                            
 /// 发布（使用序列化） /// 
 /// 
                                                                                             /// 
                                                                                             /// 
                                                                                             /// 
                                                                                             public async Task
                                                                                            
                                                                                              PublishAsync
                                                                                             
                                                                                              (RedisChannel channel, T message) { var sub = _connMultiplexer.GetSubscriber(); return await sub.PublishAsync(channel, Serialize(message)); } #endregion 发布订阅-async #endregion 发布订阅 #region private method /// 
                                                                                              
 /// 添加 Key 的前缀 /// 
 /// 
                                                                                               /// 
                                                                                               private static string AddKeyPrefix(string key) { return $"{DefaultKey}:{key}"; } #region 注册事件 /// 
                                                                                              
 /// 添加注册事件 /// 
 private static void AddRegisterEvent() { _connMultiplexer.ConnectionRestored += ConnMultiplexer_ConnectionRestored; _connMultiplexer.ConnectionFailed += ConnMultiplexer_ConnectionFailed; _connMultiplexer.ErrorMessage += ConnMultiplexer_ErrorMessage; _connMultiplexer.ConfigurationChanged += ConnMultiplexer_ConfigurationChanged; _connMultiplexer.HashSlotMoved += ConnMultiplexer_HashSlotMoved; _connMultiplexer.InternalError += ConnMultiplexer_InternalError; _connMultiplexer.ConfigurationChangedBroadcast += ConnMultiplexer_ConfigurationChangedBroadcast; } /// 
                                                                                              
 /// 重新配置广播时（通常意味着主从同步更改） /// 
 /// 
                                                                                               /// 
                                                                                               private static void ConnMultiplexer_ConfigurationChangedBroadcast(object sender, EndPointEventArgs e) { Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChangedBroadcast)}: {e.EndPoint}"); } /// 
                                                                                              
 /// 发生内部错误时（主要用于调试） /// 
 /// 
                                                                                               /// 
                                                                                               private static void ConnMultiplexer_InternalError(object sender, InternalErrorEventArgs e) { Console.WriteLine($"{nameof(ConnMultiplexer_InternalError)}: {e.Exception}"); } /// 
                                                                                              
 /// 更改集群时 /// 
 /// 
                                                                                               /// 
                                                                                               private static void ConnMultiplexer_HashSlotMoved(object sender, HashSlotMovedEventArgs e) { Console.WriteLine( $"{nameof(ConnMultiplexer_HashSlotMoved)}: {nameof(e.OldEndPoint)}-{e.OldEndPoint} To {nameof(e.NewEndPoint)}-{e.NewEndPoint}, "); } /// 
                                                                                              
 /// 配置更改时 /// 
 /// 
                                                                                               /// 
                                                                                               private static void ConnMultiplexer_ConfigurationChanged(object sender, EndPointEventArgs e) { Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChanged)}: {e.EndPoint}"); } /// 
                                                                                              
 /// 发生错误时 /// 
 /// 
                                                                                               /// 
                                                                                               private static void ConnMultiplexer_ErrorMessage(object sender, RedisErrorEventArgs e) { Console.WriteLine($"{nameof(ConnMultiplexer_ErrorMessage)}: {e.Message}"); } /// 
                                                                                              
 /// 物理连接失败时 /// 
 /// 
                                                                                               /// 
                                                                                               private static void ConnMultiplexer_ConnectionFailed(object sender, ConnectionFailedEventArgs e) { Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionFailed)}: {e.Exception}"); } /// 
                                                                                              
 /// 建立物理连接时 /// 
 /// 
                                                                                               /// 
                                                                                               private static void ConnMultiplexer_ConnectionRestored(object sender, ConnectionFailedEventArgs e) { Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionRestored)}: {e.Exception}"); } #endregion 注册事件 /// 
                                                                                              
 /// 序列化 /// 
 /// 
                                                                                               /// 
                                                                                               private static byte[] Serialize(object obj) { if (obj == null) return null; var binaryFormatter = new BinaryFormatter(); using (var memoryStream = new MemoryStream()) { binaryFormatter.Serialize(memoryStream, obj); var data = memoryStream.ToArray(); return data; } } /// 
                                                                                              
 /// 反序列化 /// 
 /// 
                                                                                               /// 
                                                                                               /// 
                                                                                               private static T Deserialize
                                                                                              
                                                                                               (byte[] data) { if (data == null) return default(T); var binaryFormatter = new BinaryFormatter(); using (var memoryStream = new MemoryStream(data)) { var result = (T)binaryFormatter.Deserialize(memoryStream); return result; } } #endregion private method }
                                                                                              
                                                                                             
                                                                                            
                                                                                           
                                                                                          
                                                                                         
                                                                                        
                                                                                       
                                                                                      
                                                                                     
                                                                                    
                                                                                   
                                                                                  
                                                                                 
                                                                                
                                                                               
                                                                              
                                                                             
                                                                            
                                                                           
                                                                          
                                                                         
                                                                        
                                                                       
                                                                      
                                                                     
                                                                    
                                                                   
                                                                  
                                                                 
                                                                
                                                               
                                                              
                                                             
                                                            
                                                           
                                                          
                                                         
                                                        
                                                       
                                                      
                                                     
                                                    
                                                   
                                                  
                                                 
                                                
                                               
                                              
                                             
                                            
                                           
                                          
                                         
                                        
                                       
                                      
                                     
                                    
                                   
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      

 

核心类 ConnectionMultiplexer

　　在 StackExchange.Redis 中最核心（中枢）的是 ConnectionMultiplexer 类，在所有调用之间它的实例对象应该被设计为在整个应用程序域中为共享和重用的，并不应该为每一个操作都创建一个 ConnectionMultiplexer 对象实例，也就是说我们可以使用常见的单例模式进行创建。

　　虽然 ConnectionMultiplexer 实现了 IDisposable 接口，但这并不意味着需要使用 using 进行释放，因为创建一个 ConnectionMultiplexer 对象是十分昂贵的 ， 所以最好的是我们一直重用一个 ConnectionMultiplexer 对象。

/// 
        /// 连接字符串        /// 
        private static readonly string ConnectionString;        /// 
        /// redis 连接对象        /// 
        private static IConnectionMultiplexer _connMultiplexer;        /// 
        /// 默认的 Key 值（用来当作 RedisKey 的前缀）        /// 
        private static readonly string DefaultKey;        /// 
        /// 锁        /// 
        private static readonly object Locker = new object();        /// 
        /// 数据库        /// 
        private readonly IDatabase _db;        /// 
        /// 获取 Redis 连接对象        /// 
        /// 
             public IConnectionMultiplexer GetConnectionRedisMultiplexer()        {            if ((_connMultiplexer == null) || !_connMultiplexer.IsConnected)            {                lock (Locker)                {                    if ((_connMultiplexer == null) || !_connMultiplexer.IsConnected)                        _connMultiplexer = ConnectionMultiplexer.Connect(ConnectionString);                }            }            return _connMultiplexer;        }

 

　　我选择让这些静态变量的字段在静态构造函数中进行统一的初始化，如连接字符串，ConnectionMultiplexer 对象和注册事件等。

#region 构造函数        static RedisHelper()        {            ConnectionString = ConfigurationManager.ConnectionStrings["RedisConnectionString"].ConnectionString;            _connMultiplexer = ConnectionMultiplexer.Connect(ConnectionString);            DefaultKey = ConfigurationManager.AppSettings["Redis.DefaultKey"];            AddRegisterEvent();        }        public RedisHelper(int db = -1)        {            _db = _connMultiplexer.GetDatabase(db);        }        #endregion 构造函数

#region 注册事件        /// 
        /// 添加注册事件        /// 
        private static void AddRegisterEvent()        {            ConnMultiplexer.ConnectionRestored += ConnMultiplexer_ConnectionRestored;            ConnMultiplexer.ConnectionFailed += ConnMultiplexer_ConnectionFailed;            ConnMultiplexer.ErrorMessage += ConnMultiplexer_ErrorMessage;            ConnMultiplexer.ConfigurationChanged += ConnMultiplexer_ConfigurationChanged;            ConnMultiplexer.HashSlotMoved += ConnMultiplexer_HashSlotMoved;            ConnMultiplexer.InternalError += ConnMultiplexer_InternalError;            ConnMultiplexer.ConfigurationChangedBroadcast += ConnMultiplexer_ConfigurationChangedBroadcast;        }        /// 
        /// 重新配置广播时（通常意味着主从同步更改）        /// 
        ///         ///         private static void ConnMultiplexer_ConfigurationChangedBroadcast(object sender, EndPointEventArgs e)        {            Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChangedBroadcast)}: {e.EndPoint}");        }        /// 
        /// 发生内部错误时（主要用于调试）        /// 
        ///         ///         private static void ConnMultiplexer_InternalError(object sender, InternalErrorEventArgs e)        {            Console.WriteLine($"{nameof(ConnMultiplexer_InternalError)}: {e.Exception}");        }        /// 
        /// 更改集群时        /// 
        ///         ///         private static void ConnMultiplexer_HashSlotMoved(object sender, HashSlotMovedEventArgs e)        {            Console.WriteLine(                $"{nameof(ConnMultiplexer_HashSlotMoved)}: {nameof(e.OldEndPoint)}-{e.OldEndPoint} To {nameof(e.NewEndPoint)}-{e.NewEndPoint}, ");        }        /// 
        /// 配置更改时        /// 
        ///         ///         private static void ConnMultiplexer_ConfigurationChanged(object sender, EndPointEventArgs e)        {            Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChanged)}: {e.EndPoint}");        }        /// 
        /// 发生错误时        /// 
        ///         ///         private static void ConnMultiplexer_ErrorMessage(object sender, RedisErrorEventArgs e)        {            Console.WriteLine($"{nameof(ConnMultiplexer_ErrorMessage)}: {e.Message}");        }        /// 
        /// 物理连接失败时        /// 
        ///         ///         private static void ConnMultiplexer_ConnectionFailed(object sender, ConnectionFailedEventArgs e)        {            Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionFailed)}: {e.Exception}");        }        /// 
        /// 建立物理连接时        /// 
        ///         ///         private static void ConnMultiplexer_ConnectionRestored(object sender, ConnectionFailedEventArgs e)        {            Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionRestored)}: {e.Exception}");        }        #endregion 注册事件

 

　　这里的 Redis.DefaultKey 和 RedisConnectionString 对应配置文件中 App.Config。

 

　　DefaultKey（默认 Key）的作用是给 redisKey 值添加一个前缀，我这里使用了命名空间作为了前缀，在 Redis 可视化工具中可以更直观的进行显示（以“:”进行字符串的拼接）。

 

字符串(String)

　　存储字符串值。所有的同步方法都带有对应的异步方法，所以也进行了简单的封装。比较常用的应该是字符串操作，直接将 value 序列化存放到 redis 中。

#region String 操作        /// 
        /// 设置 key 并保存字符串（如果 key 已存在，则覆盖值）        /// 
        ///         ///         ///         /// 
              public bool StringSet(string redisKey, string redisValue, TimeSpan? expiry = null)        {            redisKey = AddKeyPrefix(redisKey);            return _db.StringSet(redisKey, redisValue, expiry);        }        /// 
        /// 保存多个 Key-value        /// 
        ///         /// 
              public bool StringSet(IEnumerable
      
       
        > keyValuePairs)        {            keyValuePairs =                keyValuePairs.Select(x => new KeyValuePair
        
         (AddKeyPrefix(x.Key), x.Value));            return _db.StringSet(keyValuePairs.ToArray());        }        /// 
         
        /// 获取字符串        /// 
        /// 
                 /// 
                 /// 
                 public string StringGet(string redisKey, TimeSpan? expiry = null)        {            redisKey = AddKeyPrefix(redisKey);            return _db.StringGet(redisKey);        }        /// 
         
        /// 存储一个对象（该对象会被序列化保存）        /// 
        /// 
                 /// 
                 /// 
                 /// 
                 public bool StringSet
         
          (string redisKey, T redisValue, TimeSpan? expiry = null)        {            redisKey = AddKeyPrefix(redisKey);            var json = Serialize(redisValue);            return _db.StringSet(redisKey, json, expiry);        }        /// 
          
        /// 获取一个对象（会进行反序列化）        /// 
        /// 
                  /// 
                  /// 
                  public T StringGet
          
           (string redisKey, TimeSpan? expiry = null)        {            redisKey = AddKeyPrefix(redisKey);            return Deserialize
           
            (_db.StringGet(redisKey)); } #region async /// 
            
 /// 保存一个字符串值 /// 
 /// 
             /// 
             /// 
             /// 
             public async Task
            
              StringSetAsync(string redisKey, string redisValue, TimeSpan? expiry = null) { redisKey = AddKeyPrefix(redisKey); return await _db.StringSetAsync(redisKey, redisValue, expiry); } /// 
             
 /// 保存一组字符串值 /// 
 /// 
              /// 
              public async Task
             
               StringSetAsync(IEnumerable
              
               
                > keyValuePairs) { keyValuePairs = keyValuePairs.Select(x => new KeyValuePair
                
                 (AddKeyPrefix(x.Key), x.Value)); return await _db.StringSetAsync(keyValuePairs.ToArray()); } /// 
                 
 /// 获取单个值 /// 
 /// 
                  /// 
                  /// 
                  /// 
                  public async Task
                 
                   StringGetAsync(string redisKey, string redisValue, TimeSpan? expiry = null) { redisKey = AddKeyPrefix(redisKey); return await _db.StringGetAsync(redisKey); } /// 
                  
 /// 存储一个对象（该对象会被序列化保存） /// 
 /// 
                   /// 
                   /// 
                   /// 
                   public async Task
                  
                    StringSetAsync
                   
                    (string redisKey, T redisValue, TimeSpan? expiry = null) { redisKey = AddKeyPrefix(redisKey); var json = Serialize(redisValue); return await _db.StringSetAsync(redisKey, json, expiry); } /// 
                    
 /// 获取一个对象（会进行反序列化） /// 
 /// 
                     /// 
                     /// 
                     public async Task
                    
                      StringGetAsync
                     
                      (string redisKey, TimeSpan? expiry = null) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                      
                       (await _db.StringGetAsync(redisKey)); } #endregion async #endregion String 操作
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      

 

哈希(Hash)

　　哈希是一个 string 类型的 field 和 value 的映射表，哈希特别适合用于存储对象。

#region Hash 操作        /// 
        /// 判断该字段是否存在 hash 中        /// 
        ///         ///         /// 
              public bool HashExists(string redisKey, string hashField)        {            redisKey = AddKeyPrefix(redisKey);            return _db.HashExists(redisKey, hashField);        }        /// 
        /// 从 hash 中移除指定字段        /// 
        ///         ///         /// 
              public bool HashDelete(string redisKey, string hashField)        {            redisKey = AddKeyPrefix(redisKey);            return _db.HashDelete(redisKey, hashField);        }        /// 
        /// 从 hash 中移除指定字段        /// 
        ///         ///         /// 
              public long HashDelete(string redisKey, IEnumerable
      
        hashField)        {            redisKey = AddKeyPrefix(redisKey);            return _db.HashDelete(redisKey, hashField.ToArray());        }        /// 
       
        /// 在 hash 设定值        /// 
        /// 
               /// 
               /// 
               /// 
               public bool HashSet(string redisKey, string hashField, string value)        {            redisKey = AddKeyPrefix(redisKey);            return _db.HashSet(redisKey, hashField, value);        }        /// 
       
        /// 在 hash 中设定值        /// 
        /// 
               /// 
               public void HashSet(string redisKey, IEnumerable
       
         hashFields)        {            redisKey = AddKeyPrefix(redisKey);            _db.HashSet(redisKey, hashFields.ToArray());        }        /// 
        
        /// 在 hash 中获取值        /// 
        /// 
                /// 
                /// 
                public RedisValue HashGet(string redisKey, string hashField)        {            redisKey = AddKeyPrefix(redisKey);            return _db.HashGet(redisKey, hashField);        }        /// 
        
        /// 在 hash 中获取值        /// 
        /// 
                /// 
                /// 
                /// 
                public RedisValue[] HashGet(string redisKey, RedisValue[] hashField, string value)        {            redisKey = AddKeyPrefix(redisKey);            return _db.HashGet(redisKey, hashField);        }        /// 
        
        /// 从 hash 返回所有的字段值        /// 
        /// 
                /// 
                public IEnumerable
        
          HashKeys(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.HashKeys(redisKey);        }        /// 
         
        /// 返回 hash 中的所有值        /// 
        /// 
                 /// 
                 public RedisValue[] HashValues(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.HashValues(redisKey);        }        /// 
         
        /// 在 hash 设定值（序列化）        /// 
        /// 
                 /// 
                 /// 
                 /// 
                 public bool HashSet
         
          (string redisKey, string hashField, T value)        {            redisKey = AddKeyPrefix(redisKey);            var json = Serialize(value);            return _db.HashSet(redisKey, hashField, json);        }        /// 
          
        /// 在 hash 中获取值（反序列化）        /// 
        /// 
                  /// 
                  /// 
                  public T HashGet
          
           (string redisKey, string hashField)        {            redisKey = AddKeyPrefix(redisKey);            return Deserialize
           
            (_db.HashGet(redisKey, hashField)); } #region async /// 
            
 /// 判断该字段是否存在 hash 中 /// 
 /// 
             /// 
             /// 
             public async Task
            
              HashExistsAsync(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return await _db.HashExistsAsync(redisKey, hashField); } /// 
             
 /// 从 hash 中移除指定字段 /// 
 /// 
              /// 
              /// 
              public async Task
             
               HashDeleteAsync(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return await _db.HashDeleteAsync(redisKey, hashField); } /// 
              
 /// 从 hash 中移除指定字段 /// 
 /// 
               /// 
               /// 
               public async Task
              
                HashDeleteAsync(string redisKey, IEnumerable
               
                 hashField) { redisKey = AddKeyPrefix(redisKey); return await _db.HashDeleteAsync(redisKey, hashField.ToArray()); } /// 
                
 /// 在 hash 设定值 /// 
 /// 
                 /// 
                 /// 
                 /// 
                 public async Task
                
                  HashSetAsync(string redisKey, string hashField, string value) { redisKey = AddKeyPrefix(redisKey); return await _db.HashSetAsync(redisKey, hashField, value); } /// 
                 
 /// 在 hash 中设定值 /// 
 /// 
                  /// 
                  public async Task HashSetAsync(string redisKey, IEnumerable
                 
                   hashFields) { redisKey = AddKeyPrefix(redisKey); await _db.HashSetAsync(redisKey, hashFields.ToArray()); } /// 
                  
 /// 在 hash 中获取值 /// 
 /// 
                   /// 
                   /// 
                   public async Task
                  
                    HashGetAsync(string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return await _db.HashGetAsync(redisKey, hashField); } /// 
                   
 /// 在 hash 中获取值 /// 
 /// 
                    /// 
                    /// 
                    /// 
                    public async Task
                   
                    
                     > HashGetAsync(string redisKey, RedisValue[] hashField, string value) { redisKey = AddKeyPrefix(redisKey); return await _db.HashGetAsync(redisKey, hashField); } /// 
                     
 /// 从 hash 返回所有的字段值 /// 
 /// 
                      /// 
                      public async Task
                     
                      
                       > HashKeysAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.HashKeysAsync(redisKey); } /// 
                       
 /// 返回 hash 中的所有值 /// 
 /// 
                        /// 
                        public async Task
                       
                        
                         > HashValuesAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.HashValuesAsync(redisKey); } /// 
                         
 /// 在 hash 设定值（序列化） /// 
 /// 
                          /// 
                          /// 
                          /// 
                          public async Task
                         
                           HashSetAsync
                          
                           (string redisKey, string hashField, T value) { redisKey = AddKeyPrefix(redisKey); var json = Serialize(value); return await _db.HashSetAsync(redisKey, hashField, json); } /// 
                           
 /// 在 hash 中获取值（反序列化） /// 
 /// 
                            /// 
                            /// 
                            public async Task
                           
                             HashGetAsync
                            
                             (string redisKey, string hashField) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                             
                              (await _db.HashGetAsync(redisKey, hashField)); } #endregion async #endregion Hash 操作
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      

 

列表(List)

　　列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）。

#region List 操作        /// 
        /// 移除并返回存储在该键列表的第一个元素        /// 
        ///         /// 
              public string ListLeftPop(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.ListLeftPop(redisKey);        }        /// 
        /// 移除并返回存储在该键列表的最后一个元素        /// 
        ///         /// 
              public string ListRightPop(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.ListRightPop(redisKey);        }        /// 
        /// 移除列表指定键上与该值相同的元素        /// 
        ///         ///         /// 
              public long ListRemove(string redisKey, string redisValue)        {            redisKey = AddKeyPrefix(redisKey);            return _db.ListRemove(redisKey, redisValue);        }        /// 
        /// 在列表尾部插入值。如果键不存在，先创建再插入值        /// 
        ///         ///         /// 
              public long ListRightPush(string redisKey, string redisValue)        {            redisKey = AddKeyPrefix(redisKey);            return _db.ListRightPush(redisKey, redisValue);        }        /// 
        /// 在列表头部插入值。如果键不存在，先创建再插入值        /// 
        ///         ///         /// 
              public long ListLeftPush(string redisKey, string redisValue)        {            redisKey = AddKeyPrefix(redisKey);            return _db.ListLeftPush(redisKey, redisValue);        }        /// 
        /// 返回列表上该键的长度，如果不存在，返回 0        /// 
        ///         /// 
              public long ListLength(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.ListLength(redisKey);        }        /// 
        /// 返回在该列表上键所对应的元素        /// 
        ///         /// 
              public IEnumerable
      
        ListRange(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.ListRange(redisKey);        }        /// 
       
        /// 移除并返回存储在该键列表的第一个元素        /// 
        /// 
               /// 
               public T ListLeftPop
       
        (string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return Deserialize
        
         (_db.ListLeftPop(redisKey));        }        /// 
         
        /// 移除并返回存储在该键列表的最后一个元素        /// 
        /// 
                 /// 
                 public T ListRightPop
         
          (string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return Deserialize
          
           (_db.ListRightPop(redisKey));        }        /// 
           
 /// 在列表尾部插入值。如果键不存在，先创建再插入值 /// 
        /// 
                   /// 
                   /// 
                   public long ListRightPush
           
            (string redisKey, T redisValue) { redisKey = AddKeyPrefix(redisKey); return _db.ListRightPush(redisKey, Serialize(redisValue)); } /// 
            
 /// 在列表头部插入值。如果键不存在，先创建再插入值 /// 
 /// 
             /// 
             /// 
             public long ListLeftPush
            
             (string redisKey, T redisValue) { redisKey = AddKeyPrefix(redisKey); return _db.ListLeftPush(redisKey, Serialize(redisValue)); } #region List-async /// 
             
 /// 移除并返回存储在该键列表的第一个元素 /// 
 /// 
              /// 
              public async Task
             
               ListLeftPopAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.ListLeftPopAsync(redisKey); } /// 
              
 /// 移除并返回存储在该键列表的最后一个元素 /// 
 /// 
               /// 
               public async Task
              
                ListRightPopAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRightPopAsync(redisKey); } /// 
               
 /// 移除列表指定键上与该值相同的元素 /// 
 /// 
                /// 
                /// 
                public async Task
               
                 ListRemoveAsync(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRemoveAsync(redisKey, redisValue); } /// 
                
 /// 在列表尾部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                 /// 
                 /// 
                 public async Task
                
                  ListRightPushAsync(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRightPushAsync(redisKey, redisValue); } /// 
                 
 /// 在列表头部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                  /// 
                  /// 
                  public async Task
                 
                   ListLeftPushAsync(string redisKey, string redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListLeftPushAsync(redisKey, redisValue); } /// 
                  
 /// 返回列表上该键的长度，如果不存在，返回 0 /// 
 /// 
                   /// 
                   public async Task
                  
                    ListLengthAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.ListLengthAsync(redisKey); } /// 
                   
 /// 返回在该列表上键所对应的元素 /// 
 /// 
                    /// 
                    public async Task
                   
                    
                     > ListRangeAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRangeAsync(redisKey); } /// 
                     
 /// 移除并返回存储在该键列表的第一个元素 /// 
 /// 
                      /// 
                      public async Task
                     
                       ListLeftPopAsync
                      
                       (string redisKey) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                       
                        (await _db.ListLeftPopAsync(redisKey)); } /// 
                        
 /// 移除并返回存储在该键列表的最后一个元素 /// 
 /// 
                         /// 
                         public async Task
                        
                          ListRightPopAsync
                         
                          (string redisKey) { redisKey = AddKeyPrefix(redisKey); return Deserialize
                          
                           (await _db.ListRightPopAsync(redisKey)); } /// 
                           
 /// 在列表尾部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                            /// 
                            /// 
                            public async Task
                           
                             ListRightPushAsync
                            
                             (string redisKey, T redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListRightPushAsync(redisKey, Serialize(redisValue)); } /// 
                             
 /// 在列表头部插入值。如果键不存在，先创建再插入值 /// 
 /// 
                              /// 
                              /// 
                              public async Task
                             
                               ListLeftPushAsync
                              
                               (string redisKey, T redisValue) { redisKey = AddKeyPrefix(redisKey); return await _db.ListLeftPushAsync(redisKey, Serialize(redisValue)); } #endregion List-async #endregion List 操作
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      

 

有序集合(sorted set)

　　有序集合成员是唯一的，这就意味着集合中不能出现重复的数据。

#region SortedSet 操作        /// 
        /// SortedSet 新增        /// 
        ///         ///         ///         /// 
              public bool SortedSetAdd(string redisKey, string member, double score)        {            redisKey = AddKeyPrefix(redisKey);            return _db.SortedSetAdd(redisKey, member, score);        }        /// 
        /// 在有序集合中返回指定范围的元素，默认情况下从低到高。        /// 
        ///         /// 
              public IEnumerable
      
        SortedSetRangeByRank(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.SortedSetRangeByRank(redisKey);        }        /// 
       
        /// 返回有序集合的元素个数        /// 
        /// 
               /// 
               public long SortedSetLength(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.SortedSetLength(redisKey);        }        /// 
       
        /// 返回有序集合的元素个数        /// 
        /// 
               /// 
               /// 
               public bool SortedSetLength(string redisKey, string memebr)        {            redisKey = AddKeyPrefix(redisKey);            return _db.SortedSetRemove(redisKey, memebr);        }        /// 
       
        /// SortedSet 新增        /// 
        /// 
               /// 
               /// 
               /// 
               public bool SortedSetAdd
       
        (string redisKey, T member, double score)        {            redisKey = AddKeyPrefix(redisKey);            var json = Serialize(member);            return _db.SortedSetAdd(redisKey, json, score);        }        #region SortedSet-Async        /// 
        
        /// SortedSet 新增        /// 
        /// 
                /// 
                /// 
                /// 
                public async Task
        
          SortedSetAddAsync(string redisKey, string member, double score)        {            redisKey = AddKeyPrefix(redisKey);            return await _db.SortedSetAddAsync(redisKey, member, score);        }        /// 
         
        /// 在有序集合中返回指定范围的元素，默认情况下从低到高。        /// 
        /// 
                 /// 
                 public async Task
         
          
           > SortedSetRangeByRankAsync(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return await _db.SortedSetRangeByRankAsync(redisKey);        }        /// 
           
 /// 返回有序集合的元素个数 /// 
        /// 
                   /// 
                   public async Task
           
             SortedSetLengthAsync(string redisKey) { redisKey = AddKeyPrefix(redisKey); return await _db.SortedSetLengthAsync(redisKey); } /// 
            
 /// 返回有序集合的元素个数 /// 
 /// 
             /// 
             /// 
             public async Task
            
              SortedSetRemoveAsync(string redisKey, string memebr) { redisKey = AddKeyPrefix(redisKey); return await _db.SortedSetRemoveAsync(redisKey, memebr); } /// 
             
 /// SortedSet 新增 /// 
 /// 
              /// 
              /// 
              /// 
              public async Task
             
               SortedSetAddAsync
              
               (string redisKey, T member, double score) { redisKey = AddKeyPrefix(redisKey); var json = Serialize(member); return await _db.SortedSetAddAsync(redisKey, json, score); } #endregion SortedSet-Async #endregion SortedSet 操作
              
             
            
           
          
         
        
       
      

 

Key 操作

#region key 操作        /// 
        /// 移除指定 Key        /// 
        ///         /// 
              public bool KeyDelete(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.KeyDelete(redisKey);        }        /// 
        /// 移除指定 Key        /// 
        ///         /// 
              public long KeyDelete(IEnumerable
      
        redisKeys)        {            var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x));            return _db.KeyDelete(keys.ToArray());        }        /// 
       
        /// 校验 Key 是否存在        /// 
        /// 
               /// 
               public bool KeyExists(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.KeyExists(redisKey);        }        /// 
       
        /// 重命名 Key        /// 
        /// 
               /// 
               /// 
               public bool KeyRename(string redisKey, string redisNewKey)        {            redisKey = AddKeyPrefix(redisKey);            return _db.KeyRename(redisKey, redisNewKey);        }        /// 
       
        /// 设置 Key 的时间        /// 
        /// 
               /// 
               /// 
               public bool KeyExpire(string redisKey, TimeSpan? expiry)        {            redisKey = AddKeyPrefix(redisKey);            return _db.KeyExpire(redisKey, expiry);        }        #region key-async        /// 
       
        /// 移除指定 Key        /// 
        /// 
               /// 
               public async Task
       
         KeyDeleteAsync(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return await _db.KeyDeleteAsync(redisKey);        }        /// 
        
        /// 移除指定 Key        /// 
        /// 
                /// 
                public async Task
        
          KeyDeleteAsync(IEnumerable
         
           redisKeys)        {            var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x));            return await _db.KeyDeleteAsync(keys.ToArray());        }        /// 
          
        /// 校验 Key 是否存在        /// 
        /// 
                  /// 
                  public async Task
          
            KeyExistsAsync(string redisKey)        {            redisKey = AddKeyPrefix(redisKey);            return await _db.KeyExistsAsync(redisKey);        }        /// 
           
 /// 重命名 Key /// 
        /// 
                   /// 
                   /// 
                   public async Task
           
             KeyRenameAsync(string redisKey, string redisNewKey) { redisKey = AddKeyPrefix(redisKey); return await _db.KeyRenameAsync(redisKey, redisNewKey); } /// 
            
 /// 设置 Key 的时间 /// 
 /// 
             /// 
             /// 
             public async Task
            
              KeyExpireAsync(string redisKey, TimeSpan? expiry) { redisKey = AddKeyPrefix(redisKey); return await _db.KeyExpireAsync(redisKey, expiry); } #endregion key-async #endregion key 操作
            
           
          
         
        
       
      

 

发布订阅

　　一般会使用第三方的 MQ，如 RabbitMQ。

#region 发布订阅        /// 
        /// 订阅        /// 
        ///         ///         public void Subscribe(RedisChannel channel, Action
      
        handle)        {            var sub = ConnMultiplexer.GetSubscriber();            sub.Subscribe(channel, handle);        }        /// 
       
        /// 发布        /// 
        /// 
               /// 
               /// 
               public long Publish(RedisChannel channel, RedisValue message)        {            var sub = ConnMultiplexer.GetSubscriber();            return sub.Publish(channel, message);        }        /// 
       
        /// 发布（使用序列化）        /// 
        /// 
               /// 
               /// 
               /// 
               public long Publish
       
        (RedisChannel channel, T message)        {            var sub = ConnMultiplexer.GetSubscriber();            return sub.Publish(channel, Serialize(message));        }        #region 发布订阅-async        /// 
        
        /// 订阅        /// 
        /// 
                /// 
                public async Task SubscribeAsync(RedisChannel channel, Action
        
          handle)        {            var sub = ConnMultiplexer.GetSubscriber();            await sub.SubscribeAsync(channel, handle);        }        /// 
         
        /// 发布        /// 
        /// 
                 /// 
                 /// 
                 public async Task
         
           PublishAsync(RedisChannel channel, RedisValue message)        {            var sub = ConnMultiplexer.GetSubscriber();            return await sub.PublishAsync(channel, message);        }        /// 
          
        /// 发布（使用序列化）        /// 
        /// 
                  /// 
                  /// 
                  /// 
                  public async Task
          
            PublishAsync
           
            (RedisChannel channel, T message) { var sub = ConnMultiplexer.GetSubscriber(); return await sub.PublishAsync(channel, Serialize(message)); } #endregion 发布订阅-async #endregion 发布订阅
           
          
         
        
       
      

 

其他

　　这里使用了二进制序列化器进行序列化操作。

/// 
        /// 添加 Key 的前缀        /// 
        ///         /// 
             private static string AddKeyPrefix(string key)        {            return $"{DefaultKey}:{key}";        }        /// 
        /// 序列化        /// 
        ///         /// 
             private static byte[] Serialize(object obj)        {            if (obj == null)                return null;            var binaryFormatter = new BinaryFormatter();            using (var memoryStream = new MemoryStream())            {                binaryFormatter.Serialize(memoryStream, obj);                var data = memoryStream.ToArray();                return data;            }        }        /// 
        /// 反序列化        /// 
        /// 
             ///         /// 
             private static T Deserialize
     
      (byte[] data)        {            if (data == null)                return default(T);            var binaryFormatter = new BinaryFormatter();            using (var memoryStream = new MemoryStream(data))            {                var result = (T)binaryFormatter.Deserialize(memoryStream);                return result;            }        }
     

 

　　测试代码：

 

　　【备注】内部还有很多的接口和方法没有进行封装，还需要自己进行封装。 

 

【GitHub】  后续维护只在代码中

---

【博主】反骨仔

【原文】 

【参考】http://www.cnblogs.com/qtqq/p/5951201.html