.net core下Redis帮助类

　　  0.引入.net core环境下Redis的NuGet包，StackExchange.Redis，现目前最新的2.0.519。
　　　　　　

1. 帮助类Code:

    using System;
    using System.Collections.Generic;
    using StackExchange.Redis;
    using Newtonsoft.Json;
    using YJT.Web.lib;
    using YJT.Common.Log;
   
    namespace YJT.Web.Redis
    {
        /// <summary>
        /// Redis帮助类
        /// </summary>
        public class RedisHelper
        {
            //单例模式
            public static RedisCommon Default { get { return new RedisCommon(); } }
            public static RedisCommon One { get { return new RedisCommon(, UtilConf.Configuration["RedisConfig:ReadWriteHosts"] ?? "127.0.0.1:6789"); } }
            public static RedisCommon Two { get { return new RedisCommon(, UtilConf.Configuration["RedisConfig:ReadWriteHosts"] ?? "127.0.0.1:6789"); } }
            public static RedisCommon Three { get { return new RedisCommon(, UtilConf.Configuration["RedisConfig:ReadWriteHosts"] ?? "127.0.0.1:6789"); } }
        }
   
        /// <summary>
        /// Redis操作类
        /// 老版用的是ServiceStack.Redis
        /// .Net Core使用StackExchange.Redis的nuget包
        /// </summary>
        public class RedisCommon
        {
            //redis数据库连接字符串
            private string _conn = UtilConf.Configuration["RedisConfig:ReadWriteHosts"] ?? "127.0.0.1:6789";
            private int _db = ;
   
            //静态变量 保证各模块使用的是不同实例的相同链接
            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)
                    {
                        Log.Debug("RedisHelper->CacheConnection 出错\r\n", ex.Message.ToString());
                        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 = ; 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)
                {
                    Log.Debug("RedisHelper->StringGet 出错\r\n", ex.Message.ToString());
                    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 = ; i < count; i++)
                {
                    keys[i] = keyStrs[i];
                }
                try
                {
   
                    var values = CacheRedis.StringGet(keys);
                    for (var i = ; i < values.Length; i++)
                    {
                        addrs[i] = values[i];
                    }
                    return addrs;
                }
                catch (Exception ex)
                {
                    Log.Debug("RedisHelper->StringGetMany 出错\r\n", ex.Message.ToString());
                    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));
            }
            #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
        }
    }

2. using引用备注：
   using Newtonsoft.Json;//为第三方转json 对象使用的，再熟悉不过了吧
   using YJT.Common.Log;//是一个记录日志的帮助的类，你可以用你自己的来记录日志。
   using YJT.Web.lib;//此引用是获取.net core中的appsettings.json中配置的信息。 UtilConf.Configuration["RedisConfig:ReadWriteHosts"]获取
3. 获取appsettings.json的UtilConf.cs帮助类：

    using Microsoft.Extensions.Configuration;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Text;
   
    namespace YJT.Web.lib
    {
        /// <summary>
        /// 读配置文件
        /// </summary>
        public class UtilConf
        {
            private static IConfiguration config;
   
            /// <summary>
            /// 加载配置文件
            /// </summary>
            public static IConfiguration Configuration
            {
                get
                {
                    if (config != null) return config;
                    config = new ConfigurationBuilder()
                        .SetBasePath(Directory.GetCurrentDirectory())
                        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                        .Build();
                    return config;
                }
                set => config = value;
            }
        }
    }

   此类主要是获取.net core 中的json配置信息。如：UtilConf.Configuration["RedisConfig:ReadWriteHosts"]

   

4. StackExchange.Redis下的IDatabase接口还有丰富的操作方法，可自行研究补充帮助类
   

   分享至此，欢迎留言评论~~~