RedisHelper (C#)

add key=RedisServers value=172.20.2.90:9379,password=Aa+123456789 /using StackExchange.Redis;using System;using System.Collections.Generic;using System.Linq;namespace APP.Common{/// summary...

  <add key="RedisServers" value="172.20.2.90:9379,password=Aa+123456789" />

using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;

namespace APP.Common
{
    /// <summary>
    /// StackExchangeRedis帮助类
    /// </summary>
    public sealed class RedisHelper
    {
        /// <summary>
        /// Redis服务器地址
        /// </summary>
        private static readonly string ConnectionString = System.Configuration.ConfigurationManager.AppSettings["RedisServers"];

        /// <summary>
        /// 静态变量锁
        /// </summary>
        private static object _locker = new Object();

        /// <summary>
        /// 静态实例
        /// </summary>
        private static ConnectionMultiplexer _instance = null;

        /// <summary>
        /// 使用一个静态属性来返回已连接的实例，如下列中所示。这样，一旦 ConnectionMultiplexer 断开连接，便可以初始化新的连接实例。
        /// </summary>
        private static ConnectionMultiplexer Instance
        {
            get
            {
                try
                {
                    if (_instance == null)
                    {
                        lock (_locker)
                        {
                            if (_instance == null || !_instance.IsConnected)
                            {
                                _instance = ConnectionMultiplexer.Connect(ConnectionString);
                                //注册如下事件
                                _instance.ConnectionFailed += MuxerConnectionFailed;
                                _instance.ConnectionRestored += MuxerConnectionRestored;
                                _instance.ErrorMessage += MuxerErrorMessage;
                                _instance.ConfigurationChanged += MuxerConfigurationChanged;
                                _instance.HashSlotMoved += MuxerHashSlotMoved;
                                _instance.InternalError += MuxerInternalError;
                            }
                        }
                    }

                }
                catch (Exception ex)
                {
                    LogHelper.Error(typeof(RedisHelper), string.Format("redis初始化异常,连接字符串={0}", ConnectionString), ex);
                }
                return _instance;
            }
        }

        /// <summary>
        /// 获取redis数据库对象
        /// </summary>
        /// <returns></returns>
        private static IDatabase GetDatabase()
        {
            return Instance.GetDatabase();
        }

        /// <summary>
        /// 检查Key是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool Exists(string key)
        {
            if (string.IsNullOrWhiteSpace(key))
            {
                return false;
            }
            try
            {
                return GetDatabase().KeyExists(key);
            }
            catch (Exception ex)
            {
                LogHelper.Error(typeof(RedisHelper), string.Format("检查Key是否存在异常,缓存key={0}", key), ex);
            }
            return false;
        }

        /// <summary>
        /// 设置String类型的缓存对象(如果value是null或者空字符串则设置失败)
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="ts">过期时间</param>
        public static bool SetString(string key, string value, TimeSpan? ts = null)
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                return false;
            }
            try
            {
                return GetDatabase().StringSet(key, value, ts);
            }
            catch (Exception ex)
            {
                LogHelper.Error(typeof(RedisHelper), string.Format("设置string类型缓存异常,缓存key={0},缓存值={1}", key, value), ex);
            }
            return false;
        }

        /// <summary>
        /// 根据key获取String类型的缓存对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string GetString(string key)
        {
            try
            {
                return GetDatabase().StringGet(key);
            }
            catch (Exception ex)
            {
                LogHelper.Error(typeof(RedisHelper), string.Format("获取string类型缓存异常,缓存key={0}", key), ex);
            }
            return null;
        }

        /// <summary>
        /// 删除缓存
        /// </summary>
        /// <param name="key">key</param>
        /// <returns></returns>
        public static bool KeyDelete(string key)
        {
            try
            {
                return GetDatabase().KeyDelete(key);
            }
            catch (Exception ex)
            {
                LogHelper.Error(typeof(RedisHelper), "删除缓存异常,缓存key={0}" + key, ex);
                return false;
            }
        }
        /// <summary>
        /// 设置Hash类型缓存对象(如果value没有公共属性则不设置缓存)
        ///    会使用反射将object对象所有公共属性作为Hash列存储
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static void SetHash(string key, object value)
        {
            if (null == value)
            {
                return;
            }
            try
            {
                List<HashEntry> list = new List<HashEntry>();
                Type type = value.GetType();
                var propertyArray = type.GetProperties();
                foreach (var property in propertyArray)
                {
                    string propertyName = property.Name;
                    string propertyValue = property.GetValue(value).ToString();
                    list.Add(new HashEntry(propertyName, propertyValue));
                }
                if (list.Count < 1)
                {
                    return;
                }
                IDatabase db = GetDatabase();
                db.HashSet(key, list.ToArray());
            }
            catch (Exception ex)
            {
                LogHelper.Error(typeof(RedisHelper), string.Format("设置Hash类型缓存异常,缓存key={0},缓存值={1}", key, Utils.SerializeObject(value)), ex);
            }
        }

        /// <summary>
        /// 设置Hash类型缓存对象(用于存储对象)
        /// </summary>
        /// <param name="key">Key</param>
        /// <param name="value">字典,key是列名 value是列的值</param>
        public static void SetHash(string key, Dictionary<string, string> value)
        {
            if (null == value || value.Count < 1)
            {
                return;
            }
            try
            {
                HashEntry[] array = (from item in value select new HashEntry(item.Key, item.Value)).ToArray();
                IDatabase db = GetDatabase();
                db.HashSet(key, array);
            }
            catch (Exception ex)
            {
                LogHelper.Error(typeof(RedisHelper), string.Format("设置Hash类型缓存异常,缓存key={0},缓存对象值={1}", key, string.Join(",", value)), ex);
            }
        }

        /// <summary>
        /// 根据key和列数组从缓存中拿取数据(如果fieldList为空或者个数小于0返回null)
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="fieldList">列数组</param>
        /// <returns>根据列数组构造一个字典,字典中的列与入参列数组相同,字典中的值是每一列的值</returns>
        public static Dictionary<string, string> GetHash(string key, List<string> fieldList)
        {
            if (null == fieldList || fieldList.Count < 1)
            {
                return null;
            }
            try
            {
                Dictionary<string, string> dic = new Dictionary<string, string>();
                RedisValue[] array = (from item in fieldList select (RedisValue)item).ToArray();
                IDatabase db = GetDatabase();
                RedisValue[] redisValueArray = db.HashGet(key, array);
                for (int i = 0; i < redisValueArray.Length; i++)
                {
                    string field = fieldList[i];
                    string value = redisValueArray[i];
                    dic.Add(field, value);
                }
                return dic;
            }
            catch (Exception ex)
            {
                LogHelper.Error(typeof(RedisHelper), string.Format("获取Hash类型缓存异常,缓存key={0},列数组={1}", key, string.Join(",", fieldList)), ex);
            }
            return null;
        }

        /// <summary>
        /// 使用Redis incr 记录某个Key的调用次数
        /// </summary>
        /// <param name="key"></param>
        public static long SaveInvokeCount(string key)
        {
            try
            {
                return GetDatabase().StringIncrement(key);
            }
            catch { return -1; }
        }

        /// <summary>
        /// 配置更改时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
        {
            LogHelper.Warn(typeof(RedisHelper), "MuxerConfigurationChanged=>e.EndPoint=" + e.EndPoint, null);
        }

        /// <summary>
        /// 发生错误时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
            LogHelper.Error(typeof(RedisHelper), "MuxerErrorMessage=>e.EndPoint=" + e.EndPoint + ",e.Message=" + e.Message, null);
        }

        /// <summary>
        /// 重新建立连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            LogHelper.Warn(typeof(RedisHelper), "MuxerConnectionRestored=>e.ConnectionType=" + e.ConnectionType + ",e.EndPoint=" + e.EndPoint + ",e.FailureType=" + e.FailureType, e.Exception);
        }

        /// <summary>
        /// 连接失败
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            LogHelper.Error(typeof(RedisHelper), "MuxerConnectionFailed=>e.ConnectionType=" + e.ConnectionType + ",e.EndPoint=" + e.EndPoint + ",e.FailureType=" + e.FailureType, e.Exception);
        }

        /// <summary>
        /// 更改集群
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            LogHelper.Warn(typeof(RedisHelper), "MuxerHashSlotMoved=>" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint, null);
        }

        /// <summary>
        /// redis类库错误
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
            LogHelper.Error(typeof(RedisHelper), "MuxerInternalError", e.Exception);
        }
    }
}

    //写String 缓存1小时
    RedisHelper.SetString(subID, "AXB", new TimeSpan(1, 0, 0, 0));

    //写String 缓存5分钟
    RedisHelper.SetString(mobile + "_car", equipmentType, TimeSpan.FromMinutes(5));

    //写String 
    RedisHelper.SetString(strNum, strCity);

    //读String
    string strTime = RedisHelper.GetString(mobile);