StackExchange.Redis 유 니 버 설 패키지 공유

이틀 전에 친구 가 저 에 게 StackExchange.Redis 를 사용 해 본 적 이 있 느 냐 고 물 었 습 니 다.저 에 게 포장 류 를 달라 고 물 었 습 니 다.예전 에는 모두 ServiceStack.Redis 를 사 용 했 기 때문에 ServiceStack.Redis v4 버 전이 유 료 버 전 이 었 기 때문에 지금도 많은 회사 들 이 StackExchange.Redis 를 사용 하여 ServiceStack.Redis 를 버 렸 습 니 다.사실 개인 적 으로 두 개의 구동 이 모두 괜찮다 고 생각 합 니 다.다만 ServiceStack.Redis 요금 때문에 현재 많은 회사 들 이 V3 버 전 을 바탕 으로 사용 하고 있 습 니 다.V3 버 전 은 Bug 가 많 고 유지 와 업그레이드 가 없 지만 적어도 현재 저 는 Bug 를 발견 하지 못 했 습 니 다.
그러나 ServiceStack.Redis 는 StackExchange.Redis 와 비교 해 유 료 를 떠 나 StackExchange.Redis 보다 확인 이 유리 하 다.StackExchange.Redis 문 서 는 매우 적 고 국내 문 서 는 말 할 것 도 없습니다.github 에 대응 하 는 소개 문서 도 단편 적 입 니 다.이런 점 에서 저 는 StackExchange.Redis 의 작 가 는 적어도 문 서 를 보완 해 야 한다 고 생각 합 니 다.많은 것 은 소스 코드 의 예 를 봐 야 한다 고 생각 합 니 다.인터넷 에서 StackExchange.Redis 에 대한 사용 예 도 ServiceStack.Redis 보다 훨씬 적다.아무 도 사용 하지 않 는 다 는 것 이 아니 라 내 가 찾 아 보 았 을 뿐이다.대부분 String 유형의 데 이 터 를 바탕 으로 사용 하 는 패 키 징 류 이다.List,SortedSet,Hash 의 패 키 징 작업 이 매우 적 고 대체적으로 동쪽 에서 조금 쓰 고 서쪽 에서 조금 쓰 면 완전한 것 을 찾기 어렵다.일부 글 과 소스 코드 를 참고 한 후에 여 기 는 자신 이 포장 한 종 류 를 제공 하고 각종 유형 에 대한 사용 패 키 지 를 제공 하여 여러분 에 게 학습 용 으로 제공 합 니 다.만약 에 잘 쓰 지 못 한 것 이 있 으 면 여러분 도 서로 교류 할 수 있 습 니 다.
연결 멀 티 플 렉 서 패키지
먼저 커 넥 션 멀 티 플 렉 서 의 패 키 징,커 넥 션 멀 티 플 렉 서 대상 은 StackExchange.Redis 의 가장 중추 적 인 대상 이다.이러한 인 스 턴 스 는 전체 응용 프로그램 도 메 인 에서 공유 되 고 재 활용 되 어야 하기 때문에 모든 작업 에서 이 대상 을 만 드 는 인 스 턴 스 가 필요 하지 않 습 니 다.일반적으로 하나의 사례 로 이 대상 을 만 들 고 저장 합 니 다.이것 은 홈 페이지 에 도 설명 되 어 있 습 니 다.

/// <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 유 니 버 설 작업 클래스 패키지

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 는 시스템 접 두 사 를 나타 내 는 데 사 용 됩 니 다.AddSysCustomKey 방법 은 모든 key 에 접 두 사 를 추가 하 는 것 입 니 다.여 기 는 redis 라 는 key 를 명명 할 때 접 두 사 를 붙 이 는 것 을 추천 합 니 다.그리고 사용:접 두 사 를 나 누 는 것 입 니 다.여 기 는 시각 화 도 구 를 사용 하여 볼 때 구분 하기 쉽 습 니 다.예 를 들 어 제 접 두 사 는 Demo:test:(일반적으로)입 니 다.  시스템 이름:업무 이름:),그리고 당신 이 볼 때 당신 은 많은 것 을 구분 할 수 있 는 정연 함 을 발견 할 수 있 습 니 다.

String 형식의 패키지

#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

여기 서 말 하면 StackExchange.Redis 에서 대상 에 대한 저장 소 는 자체 직렬 화 와 반 직렬 화 방법 이 아니 기 때문에 ConvertJSon 과 ConvertObj 에서 저 는 JSonConvert 를 사용 하여 작 동 했 습 니 다.다른 직렬 화 와 직렬 화 로 바 꾸 려 면 이 두 가지 측면 을 직접 수정 하면 됩 니 다.또한,StackExchange.Redis 는 ServiceStack.Redis 에 비해 비동기 적 인 방법 을 제공 하기 때문에 여기 도 비동기 와 동기 화 방법 을 봉 했다.
List 형식의 패키지

#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 형식의 패키지

#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 형식의 패키지

#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     

키 관리

#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

게시 및 구독

#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     

기타

#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   

이상 은 StackExchange.Redis 의 기본 동작 에 대한 유 니 버 설 패 키 징 으로 여러분 에 게 학습 참 고 를 제공 합 니 다.잘못 쓴 것 이 있 으 면 같이 교류 하고 싶 습 니 다.
질문:
StackExchange.Redis 는 Redis 분포 식 잠 금 동작 을 제공 하지 않 았 습 니까?ServiceStack.Redis 는 AcquireLock 의 방법 을 제 공 했 습 니 다.StackExchange.Redis 소스 코드 에서 LockTake 의 방법 만 찾 았 을 뿐 다른 방법 을 찾 지 못 했 습 니 다.사용 해 본 사람 이 있다 면 제공 해 주 셨 으 면 합 니 다.
마지막 으로 원본 주소 첨부:demo
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.