.NET Framework 4.8 下使用Redis

最新推荐文章于 2024-03-13 13:52:29 发布

往事如烟&程序媛

最新推荐文章于 2024-03-13 13:52:29 发布

阅读量944

点赞数

分类专栏： .NET Framework 文章标签： .net redis

本文链接：https://blog.csdn.net/lln93988/article/details/134537881

版权

.NET Framework 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1.NuGet下搜索StackExchange.Redis包安装

2.配置文件添加

<connectionStrings>
    <!--Redis连接字符串-->
    <add name="RedisExchangeHosts" connectionString="127.0.0.0:8001,127.0.0.0:8002,127.0.0.0:8003,allowadmin=true,password=111,abortConnect=true,connectTimeout=1000,syncTimeout=10000"/>
  </connectionStrings>

3.RedisConnectionHelp.cs

using StackExchange.Redis;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Web;

/// <summary>
/// RedisConnectionHelp 的摘要说明
/// </summary>
public static class RedisConnectionHelp
{
    //系统自定义Key前缀
    public static readonly string SysCustomKey = ConfigurationManager.AppSettings["RedisKey"] ?? "";

    //单机配置：127.0.0.1:6379,allowadmin=true,password=123456  集群配置：127.0.0.1:6366,127.0.0.1:6367,127.0.0.1:6368,allowadmin=true,password=123456  
    private static readonly string RedisConnectionString = ConfigurationManager.ConnectionStrings["RedisExchangeHosts"] == null ? "" : 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;
        connect.ConfigurationChangedBroadcast += MuxerConfigurationChangedBroadcast;

        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>
    /// 发生内部错误时（主要用于调试）
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
    {
        Console.WriteLine("InternalError:Message" + e.Exception.Message);
    }

    /// <summary>
    /// 重新配置广播时（通常意味着主从同步更改）
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private static void MuxerConfigurationChangedBroadcast(object sender, EndPointEventArgs e)
    {
        Console.WriteLine($"{nameof(RedisConnectionHelp)}: {e.EndPoint}");
    }

    #endregion 事件
}

4.RedisHelper.cs

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Web;

/// <summary>
/// RedisHelper 的摘要说明
/// </summary>
public class RedisHelper
{
    private int DbNum { get; }
    private readonly ConnectionMultiplexer _conn;
    private 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);
    }

    #endregion 构造函数

    #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

    #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);
            if (!string.IsNullOrEmpty(value))
            {
                return ConvertObj<T>(value);
            }
            else
            {
                return default(T);
            }
        });
    }

    /// <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);
        });
    }

    /// <summary>
    /// 获取hashkey所有Redis key
    /// </summary>
    /// <param name="key"></param>
    /// <returns>自符串Keys集合</returns>
    public List<string> HashStringKeys(string key)
    {
        key = AddSysCustomKey(key);
        return Do(db =>
        {
            RedisValue[] values = db.HashKeys(key);
            return ConvetStringList(values);
        });
    }

    /// <summary>
    /// 获取整个Hash表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public Dictionary<string, T> HashGetAll<T>(string key)
    {
        key = AddSysCustomKey(key);
        return Do(db =>
        {
            HashEntry[] values = db.HashGetAll(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> HashGetAsync<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);
    }

    /// <summary>
    /// 获取hashkey所有Redis key
    /// </summary>
    /// <param name="key"></param>
    /// <returns>自符串Keys集合</returns>
    public async Task<List<string>> HashStringKeysAsync(string key)
    {
        key = AddSysCustomKey(key);
        RedisValue[] values = await Do(db => db.HashKeysAsync(key));
        return ConvetStringList(values);
    }

    /// <summary>
    /// 异步获取整个Hash表 (不能在主线程中调用，否则会出现死锁现象)
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="key"></param>
    /// <returns></returns>
    public async Task<Dictionary<string, T>> HashGetAllAsync<T>(string key)
    {
        key = AddSysCustomKey(key);
        HashEntry[] values = await Do(db => db.HashGetAllAsync(key));
        return ConvetList<T>(values);
    }

    #endregion 异步方法

    #endregion Hash

    #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

    #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 其他

    #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 List<string> ConvetStringList(RedisValue[] values)
    {
        List<string> result = new List<string>();
        foreach (var item in values)
        {
            var model = item.ToString();// ConvertObj<T>(item);
            result.Add(model);
        }
        return result;
    }

    private Dictionary<string, T> ConvetList<T>(HashEntry[] values)
    {
        Dictionary<string, T> result = new Dictionary<string, T>();
        foreach (var item in values)
        {
            string dictKey = item.Name.ToString(); //ConvertObj<string>(item.Name);
            var model = ConvertObj<T>(item.Value);
            result.Add(dictKey, model);
        }
        return result;
    }

    private RedisKey[] ConvertRedisKeys(List<string> redisKeys)
    {
        return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
    }

    #endregion 辅助方法
}

5.测试

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class _Default : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        RedisHelper rHelper = new RedisHelper();
        // 增加一条缓存数据，5秒后过期
        TimeSpan timeSpan = new TimeSpan(0, 0, 5);
        rHelper.StringSet("zhangsan_2024", "今年是不一样的一年", timeSpan);
        string aa=rHelper.StringGet("zhangsan_2024");
        Thread.Sleep(timeSpan);
        string bb = rHelper.StringGet("zhangsan_2024");
    }
}