Detailed explanation of StackExchange.Redis universal encapsulation class sharing

A friend asked me two days ago if I have ever used StackExchange.Redis and asked me for a package class. Since I used ServiceStack.Redis before, since ServiceStack.Redis v4 is a paid version, it is also very popular now. Some companies are using StackExchange.Redis and abandoning ServiceStack.Redis. In fact, I personally think that both drivers are good. However, due to the charging of ServiceStack.Redis, many companies are currently using the V3 version. Some people say that the V3 version has many bugs and has not been maintained or upgraded. But at least so far, I have not found any bugs. .

However, compared with StackExchange.Redis, ServiceStack.Redis has more advantages than StackExchange.Redis regardless of the charges. There are very few documents on StackExchange.Redis, let alone domestic documents. Even the corresponding introductory documents on github are very one-sided. I really think the author of StackExchange.Redis should at least improve the documents. Many of them depend on the source code. There are only examples. There are far fewer examples of using StackExchange.Redis on the Internet than ServiceStack.Redis. It’s not that no one uses it, but I’ve looked it up and found that most of them are encapsulation classes based on String type data. For List, SortedSet, There are very few encapsulation operations in Hash. They are basically written a little east and a little west. It is difficult to find a complete one. After referring to some articles and source code, here is a self-encapsulated class, which basically provides various types of usage encapsulation for everyone to learn and use. If there is anything that is not well written, everyone can also communicate with each other.

ConnectionMultiplexer Encapsulation

The first is the encapsulation of ConnectionMultiplexer. The ConnectionMultiplexer object is the most central object of StackExchange.Redis. Instances of this class need to be shared and reused by the entire application domain, so there is no need to constantly create instances of this object in each operation. Generally, a singleton is used to create and store this object. This is also available on the official website illustrate.

/// <summary>
 /// ConnectionMultiplexer对象管理帮助类
 /// </summary>
 public static class RedisConnectionHelp
 {
  //系统自定义Key前缀
  public static readonly string SysCustomKey = ConfigurationManager.AppSettings["redisKey"] ?? "";
 
  //"127.0.0.1:6379,allowadmin=true
  private static readonly string RedisConnectionString = ConfigurationManager.ConnectionStrings["RedisExchangeHosts"].ConnectionString;
 
  private static readonly object Locker = new object();
  private static ConnectionMultiplexer _instance;
  private static readonly ConcurrentDictionary<string, ConnectionMultiplexer> ConnectionCache = new ConcurrentDictionary<string, ConnectionMultiplexer>();
 
  /// <summary>
  /// 单例获取
  /// </summary>
  public static ConnectionMultiplexer Instance
  {
   get
   {
    if (_instance == null)
    {
     lock (Locker)
     {
      if (_instance == null || !_instance.IsConnected)
      {
       _instance = GetManager();
      }
     }
    }
    return _instance;
   }
  }
 
  /// <summary>
  /// 缓存获取
  /// </summary>
  /// <param name="connectionString"></param>
  /// <returns></returns>
  public static ConnectionMultiplexer GetConnectionMultiplexer(string connectionString)
  {
   if (!ConnectionCache.ContainsKey(connectionString))
   {
    ConnectionCache[connectionString] = GetManager(connectionString);
   }
   return ConnectionCache[connectionString];
  }
 
  private static ConnectionMultiplexer GetManager(string connectionString = null)
  {
   connectionString = connectionString ?? RedisConnectionString;
   var connect = ConnectionMultiplexer.Connect(connectionString);
 
   //注册如下事件
   connect.ConnectionFailed += MuxerConnectionFailed;
   connect.ConnectionRestored += MuxerConnectionRestored;
   connect.ErrorMessage += MuxerErrorMessage;
   connect.ConfigurationChanged += MuxerConfigurationChanged;
   connect.HashSlotMoved += MuxerHashSlotMoved;
   connect.InternalError += MuxerInternalError;
 
   return connect;
  }
 
  #region 事件
 
  /// <summary>
  /// 配置更改时
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
  {
   Console.WriteLine("Configuration changed: " + e.EndPoint);
  }
 
  /// <summary>
  /// 发生错误时
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
  {
   Console.WriteLine("ErrorMessage: " + e.Message);
  }
 
  /// <summary>
  /// 重新建立连接之前的错误
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
  {
   Console.WriteLine("ConnectionRestored: " + e.EndPoint);
  }
 
  /// <summary>
  /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
  {
   Console.WriteLine("重新连接：Endpoint failed: " + e.EndPoint + ", " + e.FailureType + (e.Exception == null ? "" : (", " + e.Exception.Message)));
  }
 
  /// <summary>
  /// 更改集群
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
  {
   Console.WriteLine("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
  }
 
  /// <summary>
  /// redis类库错误
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
  {
   Console.WriteLine("InternalError:Message" + e.Exception.Message);
  }
 
  #endregion 事件
 }

RedisHelper general operation class seal

public class RedisHelper
 {
  private int DbNum { get; }
  private readonly ConnectionMultiplexer _conn;
  public string CustomKey;
 
  #region 构造函数
 
  public RedisHelper(int dbNum = 0)
    : this(dbNum, null)
  {
  }
 
  public RedisHelper(int dbNum, string readWriteHosts)
  {
   DbNum = dbNum;
   _conn =
    string.IsNullOrWhiteSpace(readWriteHosts) ?
    RedisConnectionHelp.Instance :
    RedisConnectionHelp.GetConnectionMultiplexer(readWriteHosts);
  }
 
#region 辅助方法
 
  private string AddSysCustomKey(string oldKey)
  {
   var prefixKey = CustomKey ?? RedisConnectionHelp.SysCustomKey;
   return prefixKey + oldKey;
  }
 
  private T Do<T>(Func<IDatabase, T> func)
  {
   var database = _conn.GetDatabase(DbNum);
   return func(database);
  }
 
  private string ConvertJson<T>(T value)
  {
   string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
   return result;
  }
 
  private T ConvertObj<T>(RedisValue value)
  {
   return JsonConvert.DeserializeObject<T>(value);
  }
 
  private List<T> ConvetList<T>(RedisValue[] values)
  {
   List<T> result = new List<T>();
   foreach (var item in values)
   {
    var model = ConvertObj<T>(item);
    result.Add(model);
   }
   return result;
  }
 
  private RedisKey[] ConvertRedisKeys(List<string> redisKeys)
  {
   return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
  }
 
  #endregion 辅助方法
 
  #endregion 构造函数
}

CustomKey is used to represent the system prefix. The AddSysCustomKey method adds a prefix to each key. It is recommended that you name the redis key here. It is best to add a prefix and use: to separate the prefix. It is easier to distinguish when viewing it with a visual tool. For example, my prefix is ​​Demo:test: (usually system name: business name:), and then you When you check it, you will find that it is neat and easy to distinguish a lot of

String type encapsulation

#region String
 
  #region 同步方法
 
  /// <summary>
  /// 保存单个key value
  /// </summary>
  /// <param name="key">Redis Key</param>
  /// <param name="value">保存的值</param>
  /// <param name="expiry">过期时间</param>
  /// <returns></returns>
  public bool StringSet(string key, string value, TimeSpan? expiry = default(TimeSpan?))
  {
   key = AddSysCustomKey(key);
   return Do(db => db.StringSet(key, value, expiry));
  }
 
  /// <summary>
  /// 保存多个key value
  /// </summary>
  /// <param name="keyValues">键值对</param>
  /// <returns></returns>
  public bool StringSet(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
  {
   List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
    keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToList();
   return Do(db => db.StringSet(newkeyValues.ToArray()));
  }
 
  /// <summary>
  /// 保存一个对象
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <param name="obj"></param>
  /// <param name="expiry"></param>
  /// <returns></returns>
  public bool StringSet<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
  {
   key = AddSysCustomKey(key);
   string json = ConvertJson(obj);
   return Do(db => db.StringSet(key, json, expiry));
  }
 
  /// <summary>
  /// 获取单个key的值
  /// </summary>
  /// <param name="key">Redis Key</param>
  /// <returns></returns>
  public string StringGet(string key)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.StringGet(key));
  }
 
  /// <summary>
  /// 获取多个Key
  /// </summary>
  /// <param name="listKey">Redis Key集合</param>
  /// <returns></returns>
  public RedisValue[] StringGet(List<string> listKey)
  {
   List<string> newKeys = listKey.Select(AddSysCustomKey).ToList();
   return Do(db => db.StringGet(ConvertRedisKeys(newKeys)));
  }
 
  /// <summary>
  /// 获取一个key的对象
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public T StringGet<T>(string key)
  {
   key = AddSysCustomKey(key);
   return Do(db => ConvertObj<T>(db.StringGet(key)));
  }
 
  /// <summary>
  /// 为数字增长val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="val">可以为负</param>
  /// <returns>增长后的值</returns>
  public double StringIncrement(string key, double val = 1)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.StringIncrement(key, val));
  }
 
  /// <summary>
  /// 为数字减少val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="val">可以为负</param>
  /// <returns>减少后的值</returns>
  public double StringDecrement(string key, double val = 1)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.StringDecrement(key, val));
  }
 
  #endregion 同步方法
 
  #region 异步方法
 
  /// <summary>
  /// 保存单个key value
  /// </summary>
  /// <param name="key">Redis Key</param>
  /// <param name="value">保存的值</param>
  /// <param name="expiry">过期时间</param>
  /// <returns></returns>
  public async Task<bool> StringSetAsync(string key, string value, TimeSpan? expiry = default(TimeSpan?))
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.StringSetAsync(key, value, expiry));
  }
 
  /// <summary>
  /// 保存多个key value
  /// </summary>
  /// <param name="keyValues">键值对</param>
  /// <returns></returns>
  public async Task<bool> StringSetAsync(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
  {
   List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
    keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToList();
   return await Do(db => db.StringSetAsync(newkeyValues.ToArray()));
  }
 
  /// <summary>
  /// 保存一个对象
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <param name="obj"></param>
  /// <param name="expiry"></param>
  /// <returns></returns>
  public async Task<bool> StringSetAsync<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
  {
   key = AddSysCustomKey(key);
   string json = ConvertJson(obj);
   return await Do(db => db.StringSetAsync(key, json, expiry));
  }
 
  /// <summary>
  /// 获取单个key的值
  /// </summary>
  /// <param name="key">Redis Key</param>
  /// <returns></returns>
  public async Task<string> StringGetAsync(string key)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.StringGetAsync(key));
  }
 
  /// <summary>
  /// 获取多个Key
  /// </summary>
  /// <param name="listKey">Redis Key集合</param>
  /// <returns></returns>
  public async Task<RedisValue[]> StringGetAsync(List<string> listKey)
  {
   List<string> newKeys = listKey.Select(AddSysCustomKey).ToList();
   return await Do(db => db.StringGetAsync(ConvertRedisKeys(newKeys)));
  }
 
  /// <summary>
  /// 获取一个key的对象
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public async Task<T> StringGetAsync<T>(string key)
  {
   key = AddSysCustomKey(key);
   string result = await Do(db => db.StringGetAsync(key));
   return ConvertObj<T>(result);
  }
 
  /// <summary>
  /// 为数字增长val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="val">可以为负</param>
  /// <returns>增长后的值</returns>
  public async Task<double> StringIncrementAsync(string key, double val = 1)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.StringIncrementAsync(key, val));
  }
 
  /// <summary>
  /// 为数字减少val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="val">可以为负</param>
  /// <returns>减少后的值</returns>
  public async Task<double> StringDecrementAsync(string key, double val = 1)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.StringDecrementAsync(key, val));
  }
 
  #endregion 异步方法
 
  #endregion String

Let’s talk about the storage of objects in StackExchange.Redis It does not come with serialization and deserialization methods, so I use JsonConvert in ConvertJson and ConvertObj. If you need to change to other serialization and deserialization, just modify these two aspects directly. In addition, , StackExchange.Redis provides asynchronous methods compared to ServiceStack.Redis, so asynchronous and synchronous methods are also encapsulated here.

List type encapsulation

#region List
 
  #region 同步方法
 
  /// <summary>
  /// 移除指定ListId的内部List的值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public void ListRemove<T>(string key, T value)
  {
   key = AddSysCustomKey(key);
   Do(db => db.ListRemove(key, ConvertJson(value)));
  }
 
  /// <summary>
  /// 获取指定key的List
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public List<T> ListRange<T>(string key)
  {
   key = AddSysCustomKey(key);
   return Do(redis =>
   {
    var values = redis.ListRange(key);
    return ConvetList<T>(values);
   });
  }
 
  /// <summary>
  /// 入队
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public void ListRightPush<T>(string key, T value)
  {
   key = AddSysCustomKey(key);
   Do(db => db.ListRightPush(key, ConvertJson(value)));
  }
 
  /// <summary>
  /// 出队
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public T ListRightPop<T>(string key)
  {
   key = AddSysCustomKey(key);
   return Do(db =>
    {
     var value = db.ListRightPop(key);
     return ConvertObj<T>(value);
    });
  }
 
  /// <summary>
  /// 入栈
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public void ListLeftPush<T>(string key, T value)
  {
   key = AddSysCustomKey(key);
   Do(db => db.ListLeftPush(key, ConvertJson(value)));
  }
 
  /// <summary>
  /// 出栈
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public T ListLeftPop<T>(string key)
  {
   key = AddSysCustomKey(key);
   return Do(db =>
   {
    var value = db.ListLeftPop(key);
    return ConvertObj<T>(value);
   });
  }
 
  /// <summary>
  /// 获取集合中的数量
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public long ListLength(string key)
  {
   key = AddSysCustomKey(key);
   return Do(redis => redis.ListLength(key));
  }
 
  #endregion 同步方法
 
  #region 异步方法
 
  /// <summary>
  /// 移除指定ListId的内部List的值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public async Task<long> ListRemoveAsync<T>(string key, T value)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.ListRemoveAsync(key, ConvertJson(value)));
  }
 
  /// <summary>
  /// 获取指定key的List
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public async Task<List<T>> ListRangeAsync<T>(string key)
  {
   key = AddSysCustomKey(key);
   var values = await Do(redis => redis.ListRangeAsync(key));
   return ConvetList<T>(values);
  }
 
  /// <summary>
  /// 入队
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public async Task<long> ListRightPushAsync<T>(string key, T value)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.ListRightPushAsync(key, ConvertJson(value)));
  }
 
  /// <summary>
  /// 出队
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public async Task<T> ListRightPopAsync<T>(string key)
  {
   key = AddSysCustomKey(key);
   var value = await Do(db => db.ListRightPopAsync(key));
   return ConvertObj<T>(value);
  }
 
  /// <summary>
  /// 入栈
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public async Task<long> ListLeftPushAsync<T>(string key, T value)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.ListLeftPushAsync(key, ConvertJson(value)));
  }
 
  /// <summary>
  /// 出栈
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public async Task<T> ListLeftPopAsync<T>(string key)
  {
   key = AddSysCustomKey(key);
   var value = await Do(db => db.ListLeftPopAsync(key));
   return ConvertObj<T>(value);
  }
 
  /// <summary>
  /// 获取集合中的数量
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public async Task<long> ListLengthAsync(string key)
  {
   key = AddSysCustomKey(key);
   return await Do(redis => redis.ListLengthAsync(key));
  }
 
  #endregion 异步方法
 
  #endregion List

Hash type encapsulation

#region Hash
 
  #region 同步方法
 
  /// <summary>
  /// 判断某个数据是否已经被缓存
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <returns></returns>
  public bool HashExists(string key, string dataKey)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.HashExists(key, dataKey));
  }
 
  /// <summary>
  /// 存储数据到hash表
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <param name="t"></param>
  /// <returns></returns>
  public bool HashSet<T>(string key, string dataKey, T t)
  {
   key = AddSysCustomKey(key);
   return Do(db =>
   {
    string json = ConvertJson(t);
    return db.HashSet(key, dataKey, json);
   });
  }
 
  /// <summary>
  /// 移除hash中的某值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <returns></returns>
  public bool HashDelete(string key, string dataKey)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.HashDelete(key, dataKey));
  }
 
  /// <summary>
  /// 移除hash中的多个值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKeys"></param>
  /// <returns></returns>
  public long HashDelete(string key, List<RedisValue> dataKeys)
  {
   key = AddSysCustomKey(key);
   //List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
   return Do(db => db.HashDelete(key, dataKeys.ToArray()));
  }
 
  /// <summary>
  /// 从hash表获取数据
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <returns></returns>
  public T HashGet<T>(string key, string dataKey)
  {
   key = AddSysCustomKey(key);
   return Do(db =>
   {
    string value = db.HashGet(key, dataKey);
    return ConvertObj<T>(value);
   });
  }
 
  /// <summary>
  /// 为数字增长val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <param name="val">可以为负</param>
  /// <returns>增长后的值</returns>
  public double HashIncrement(string key, string dataKey, double val = 1)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.HashIncrement(key, dataKey, val));
  }
 
  /// <summary>
  /// 为数字减少val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <param name="val">可以为负</param>
  /// <returns>减少后的值</returns>
  public double HashDecrement(string key, string dataKey, double val = 1)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.HashDecrement(key, dataKey, val));
  }
 
  /// <summary>
  /// 获取hashkey所有Redis key
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public List<T> HashKeys<T>(string key)
  {
   key = AddSysCustomKey(key);
   return Do(db =>
   {
    RedisValue[] values = db.HashKeys(key);
    return ConvetList<T>(values);
   });
  }
 
  #endregion 同步方法
 
  #region 异步方法
 
  /// <summary>
  /// 判断某个数据是否已经被缓存
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <returns></returns>
  public async Task<bool> HashExistsAsync(string key, string dataKey)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.HashExistsAsync(key, dataKey));
  }
 
  /// <summary>
  /// 存储数据到hash表
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <param name="t"></param>
  /// <returns></returns>
  public async Task<bool> HashSetAsync<T>(string key, string dataKey, T t)
  {
   key = AddSysCustomKey(key);
   return await Do(db =>
   {
    string json = ConvertJson(t);
    return db.HashSetAsync(key, dataKey, json);
   });
  }
 
  /// <summary>
  /// 移除hash中的某值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <returns></returns>
  public async Task<bool> HashDeleteAsync(string key, string dataKey)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.HashDeleteAsync(key, dataKey));
  }
 
  /// <summary>
  /// 移除hash中的多个值
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKeys"></param>
  /// <returns></returns>
  public async Task<long> HashDeleteAsync(string key, List<RedisValue> dataKeys)
  {
   key = AddSysCustomKey(key);
   //List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
   return await Do(db => db.HashDeleteAsync(key, dataKeys.ToArray()));
  }
 
  /// <summary>
  /// 从hash表获取数据
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <returns></returns>
  public async Task<T> HashGeAsync<T>(string key, string dataKey)
  {
   key = AddSysCustomKey(key);
   string value = await Do(db => db.HashGetAsync(key, dataKey));
   return ConvertObj<T>(value);
  }
 
  /// <summary>
  /// 为数字增长val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <param name="val">可以为负</param>
  /// <returns>增长后的值</returns>
  public async Task<double> HashIncrementAsync(string key, string dataKey, double val = 1)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.HashIncrementAsync(key, dataKey, val));
  }
 
  /// <summary>
  /// 为数字减少val
  /// </summary>
  /// <param name="key"></param>
  /// <param name="dataKey"></param>
  /// <param name="val">可以为负</param>
  /// <returns>减少后的值</returns>
  public async Task<double> HashDecrementAsync(string key, string dataKey, double val = 1)
  {
   key = AddSysCustomKey(key);
   return await Do(db => db.HashDecrementAsync(key, dataKey, val));
  }
 
  /// <summary>
  /// 获取hashkey所有Redis key
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="key"></param>
  /// <returns></returns>
  public async Task<List<T>> HashKeysAsync<T>(string key)
  {
   key = AddSysCustomKey(key);
   RedisValue[] values = await Do(db => db.HashKeysAsync(key));
   return ConvetList<T>(values);
  }
 
  #endregion 异步方法
 
  #endregion Hash

SortedSet type encapsulation

#region SortedSet 有序集合
 
  #region 同步方法
 
  /// <summary>
  /// 添加
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  /// <param name="score"></param>
  public bool SortedSetAdd<T>(string key, T value, double score)
  {
   key = AddSysCustomKey(key);
   return Do(redis => redis.SortedSetAdd(key, ConvertJson<T>(value), score));
  }
 
  /// <summary>
  /// 删除
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public bool SortedSetRemove<T>(string key, T value)
  {
   key = AddSysCustomKey(key);
   return Do(redis => redis.SortedSetRemove(key, ConvertJson(value)));
  }
 
  /// <summary>
  /// 获取全部
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public List<T> SortedSetRangeByRank<T>(string key)
  {
   key = AddSysCustomKey(key);
   return Do(redis =>
   {
    var values = redis.SortedSetRangeByRank(key);
    return ConvetList<T>(values);
   });
  }
 
  /// <summary>
  /// 获取集合中的数量
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public long SortedSetLength(string key)
  {
   key = AddSysCustomKey(key);
   return Do(redis => redis.SortedSetLength(key));
  }
 
  #endregion 同步方法
 
  #region 异步方法
 
  /// <summary>
  /// 添加
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  /// <param name="score"></param>
  public async Task<bool> SortedSetAddAsync<T>(string key, T value, double score)
  {
   key = AddSysCustomKey(key);
   return await Do(redis => redis.SortedSetAddAsync(key, ConvertJson<T>(value), score));
  }
 
  /// <summary>
  /// 删除
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public async Task<bool> SortedSetRemoveAsync<T>(string key, T value)
  {
   key = AddSysCustomKey(key);
   return await Do(redis => redis.SortedSetRemoveAsync(key, ConvertJson(value)));
  }
 
  /// <summary>
  /// 获取全部
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public async Task<List<T>> SortedSetRangeByRankAsync<T>(string key)
  {
   key = AddSysCustomKey(key);
   var values = await Do(redis => redis.SortedSetRangeByRankAsync(key));
   return ConvetList<T>(values);
  }
 
  /// <summary>
  /// 获取集合中的数量
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  public async Task<long> SortedSetLengthAsync(string key)
  {
   key = AddSysCustomKey(key);
   return await Do(redis => redis.SortedSetLengthAsync(key));
  }
 
  #endregion 异步方法
 
  #endregion SortedSet 有序集合

key management

#region key
 
  /// <summary>
  /// 删除单个key
  /// </summary>
  /// <param name="key">redis key</param>
  /// <returns>是否删除成功</returns>
  public bool KeyDelete(string key)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.KeyDelete(key));
  }
 
  /// <summary>
  /// 删除多个key
  /// </summary>
  /// <param name="keys">rediskey</param>
  /// <returns>成功删除的个数</returns>
  public long KeyDelete(List<string> keys)
  {
   List<string> newKeys = keys.Select(AddSysCustomKey).ToList();
   return Do(db => db.KeyDelete(ConvertRedisKeys(newKeys)));
  }
 
  /// <summary>
  /// 判断key是否存储
  /// </summary>
  /// <param name="key">redis key</param>
  /// <returns></returns>
  public bool KeyExists(string key)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.KeyExists(key));
  }
 
  /// <summary>
  /// 重新命名key
  /// </summary>
  /// <param name="key">就的redis key</param>
  /// <param name="newKey">新的redis key</param>
  /// <returns></returns>
  public bool KeyRename(string key, string newKey)
  {
   key = AddSysCustomKey(key);
   return Do(db => db.KeyRename(key, newKey));
  }
 
  /// <summary>
  /// 设置Key的时间
  /// </summary>
  /// <param name="key">redis key</param>
  /// <param name="expiry"></param>
  /// <returns></returns>
  public bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
  {
   key = AddSysCustomKey(key);
   return Do(db => db.KeyExpire(key, expiry));
  }
 
  #endregion key

Publish And subscription

#region 发布订阅
 
  /// <summary>
  /// Redis发布订阅 订阅
  /// </summary>
  /// <param name="subChannel"></param>
  /// <param name="handler"></param>
  public void Subscribe(string subChannel, Action<RedisChannel, RedisValue> handler = null)
  {
   ISubscriber sub = _conn.GetSubscriber();
   sub.Subscribe(subChannel, (channel, message) =>
   {
    if (handler == null)
    {
     Console.WriteLine(subChannel + " 订阅收到消息：" + message);
    }
    else
    {
     handler(channel, message);
    }
   });
  }
 
  /// <summary>
  /// Redis发布订阅 发布
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="channel"></param>
  /// <param name="msg"></param>
  /// <returns></returns>
  public long Publish<T>(string channel, T msg)
  {
   ISubscriber sub = _conn.GetSubscriber();
   return sub.Publish(channel, ConvertJson(msg));
  }
 
  /// <summary>
  /// Redis发布订阅 取消订阅
  /// </summary>
  /// <param name="channel"></param>
  public void Unsubscribe(string channel)
  {
   ISubscriber sub = _conn.GetSubscriber();
   sub.Unsubscribe(channel);
  }
 
  /// <summary>
  /// Redis发布订阅 取消全部订阅
  /// </summary>
  public void UnsubscribeAll()
  {
   ISubscriber sub = _conn.GetSubscriber();
   sub.UnsubscribeAll();
  }
 
  #endregion 发布订阅

Others

#region 其他
 
  public ITransaction CreateTransaction()
  {
   return GetDatabase().CreateTransaction();
  }
 
  public IDatabase GetDatabase()
  {
   return _conn.GetDatabase(DbNum);
  }
 
  public IServer GetServer(string hostAndPort)
  {
   return _conn.GetServer(hostAndPort);
  }
 
  /// <summary>
  /// 设置前缀
  /// </summary>
  /// <param name="customKey"></param>
  public void SetSysCustomKey(string customKey)
  {
   CustomKey = customKey;
  }
 
  #endregion 其他

The above is a general encapsulation of the basic operations of StackExchange.Redis, which is provided for everyone to learn from. If there is anything wrong, I hope we can communicate together.

Question:

StackExchange.Redis does not provide Redis distributed lock operations? ServiceStack.Redis provides the AcquireLock method to operate. Only the LockTake method is found in the StackExchange.Redis source code, and no other methods are found. If anyone has used it, I hope it can be provided.

For more detailed information on StackExchange.Redis universal encapsulation class sharing related articles, please pay attention to the PHP Chinese website!