C# redis 操作工具类

{
    public class RedisHelper
    {
        public class RedisCommon
        {
            //redis数据库连接字符串
            private string _conn = ConfigurationManager.AppSettings["RedisConnection"]?.ToString();//连接字符串
            private string _instanceName = ConfigurationManager.AppSettings["RedisInstanceName"]?.ToString();//实例名称
            private int _db = ConfigurationManager.AppSettings["RedisDefaultDB"].ToIntWDV();//默认数据库 

            //静态变量 保证各模块使用的是不同实例的相同链接
            private static ConnectionMultiplexer connection;

            /// <summary>
            /// 构造函数
            /// </summary>
            public RedisCommon()
            {

            }

            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="db"></param>
            /// <param name="connectStr"></param>
            public RedisCommon(int db, string connectStr)
            {
                _db = db;
                _conn = connectStr;
            }

            /// <summary>
            /// 缓存数据库，数据库连接
            /// </summary>
            public ConnectionMultiplexer CacheConnection
            {
                get
                {
                    try
                    {
                        if (connection == null || !connection.IsConnected)
                        {
                            connection = new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(_conn)).Value;
                        }
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                        //return null;
                    }
                    return connection;
                }
            }

            /// <summary>
            /// 缓存数据库
            /// </summary>
            public IDatabase CacheRedis => CacheConnection.GetDatabase(_db);


            #region --KEY/VALUE存取--
            /// <summary>
            /// 单条存值
            /// </summary>
            /// <param name="key">key</param>
            /// <param name="value">The value.</param>
            /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
            public bool StringSet(string key, string value)
            {
                return CacheRedis.StringSet(key, value);
            }

            /// <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?))
            {
                return CacheRedis.StringSet(key, value, expiry);
            }

            /// <summary>
            /// 保存多个key value
            /// </summary>
            /// <param name="arr">key</param>
            /// <returns></returns>
            public bool StringSet(KeyValuePair<RedisKey, RedisValue>[] arr)
            {
                return CacheRedis.StringSet(arr);
            }

            /// <summary>
            /// 批量存值
            /// </summary>
            /// <param name="keysStr">key</param>
            /// <param name="valuesStr">The value.</param>
            /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
            public bool StringSetMany(string[] keysStr, string[] valuesStr)
            {
                var count = keysStr.Length;
                var keyValuePair = new KeyValuePair<RedisKey, RedisValue>[count];
                for (int i = 0; i < count; i++)
                {
                    keyValuePair[i] = new KeyValuePair<RedisKey, RedisValue>(keysStr[i], valuesStr[i]);
                }

                return CacheRedis.StringSet(keyValuePair);
            }

            /// <summary>
            /// 保存一个对象
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="obj"></param>
            /// <returns></returns>
            public bool SetStringKey<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
            {
                string json = JsonConvert.SerializeObject(obj);
                return CacheRedis.StringSet(key, json, expiry);
            }

            /// <summary>
            /// 追加值
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public void StringAppend(string key, string value)
            {
                追加值，返回追加后长度
                long appendlong = CacheRedis.StringAppend(key, value);
            }

            /// <summary>
            /// 获取单个key的值
            /// </summary>
            /// <param name="key">Redis Key</param>
            /// <returns></returns>
            public RedisValue GetStringKey(string key)
            {
                return CacheRedis.StringGet(key);
            }

            /// <summary>
            /// 根据Key获取值
            /// </summary>
            /// <param name="key">键值</param>
            /// <returns>System.String.</returns>
            public string StringGet(string key)
            {
                try
                {
                    return CacheRedis.StringGet(key);
                }
                catch (Exception ex)
                {
                    return null;
                }
            }

            /// <summary>
            /// 获取多个Key
            /// </summary>
            /// <param name="listKey">Redis Key集合</param>
            /// <returns></returns>
            public RedisValue[] GetStringKey(List<RedisKey> listKey)
            {
                return CacheRedis.StringGet(listKey.ToArray());
            }

            /// <summary>
            /// 批量获取值
            /// </summary>
            public string[] StringGetMany(string[] keyStrs)
            {
                var count = keyStrs.Length;
                var keys = new RedisKey[count];
                var addrs = new string[count];

                for (var i = 0; i < count; i++)
                {
                    keys[i] = keyStrs[i];
                }
                try
                {

                    var values = CacheRedis.StringGet(keys);
                    for (var i = 0; i < values.Length; i++)
                    {
                        addrs[i] = values[i];
                    }
                    return addrs;
                }
                catch (Exception ex)
                {
                    return null;
                }
            }

            /// <summary>
            /// 获取一个key的对象
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <returns></returns>
            public T GetStringKey<T>(string key)
            {
                return JsonConvert.DeserializeObject<T>(CacheRedis.StringGet(key));
            }

            public bool LockTake(string key, string value)
            {
                return CacheRedis.LockTake(key, value, TimeSpan.FromSeconds(60));
            }

            public bool LockRelease(string key, string value)
            {
                return CacheRedis.LockRelease(key, value);
            }
            #endregion


            #region --删除设置过期--
            /// <summary>
            /// 删除单个key
            /// </summary>
            /// <param name="key">redis key</param>
            /// <returns>是否删除成功</returns>
            public bool KeyDelete(string key)
            {
                return CacheRedis.KeyDelete(key);
            }

            /// <summary>
            /// 删除多个key
            /// </summary>
            /// <param name="keys">rediskey</param>
            /// <returns>成功删除的个数</returns>
            public long KeyDelete(RedisKey[] keys)
            {
                return CacheRedis.KeyDelete(keys);
            }

            /// <summary>
            /// 判断key是否存储
            /// </summary>
            /// <param name="key">redis key</param>
            /// <returns></returns>
            public bool KeyExists(string key)
            {
                return CacheRedis.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)
            {
                return CacheRedis.KeyRename(key, newKey);
            }

            /// <summary>
            /// 删除hasekey
            /// </summary>
            /// <param name="key"></param>
            /// <param name="hashField"></param>
            /// <returns></returns>
            public bool HaseDelete(RedisKey key, RedisValue hashField)
            {
                return CacheRedis.HashDelete(key, hashField);
            }

            /// <summary>
            /// 移除hash中的某值
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="key"></param>
            /// <param name="dataKey"></param>
            /// <returns></returns>
            public bool HashRemove(string key, string dataKey)
            {
                return CacheRedis.HashDelete(key, dataKey);
            }

            /// <summary>
            /// 设置缓存过期
            /// </summary>
            /// <param name="key"></param>
            /// <param name="datetime"></param>
            public void SetExpire(string key, DateTime datetime)
            {
                CacheRedis.KeyExpire(key, datetime);
            }
            #endregion

            public bool SetHashValue(string key, string hashField, string value) 
            {
                return CacheRedis.HashSet(key, hashField, value);
            }

            public string GetHashValue(string key, string hashField)
            {
                return CacheRedis.HashGet(key, hashField);
            }
        }
    }
}