5.C#编写Redis访问类

那么通过前面几篇博文，服务端的安装和配置应该没什么问题了，接下来的问题是如何通过代码来访问Redis。

这里我们使用的库为：

StackExchange.Redis

GitHub：https://github.com/StackExchange/StackExchange.Redis

NuGet：PM> Install-Package StackExchange.Redis

Newtonsoft.Json(Json.NET)

GitHub：https://github.com/JamesNK/Newtonsoft.Json

NuGet：PM> Install-Package Newtonsoft.Json

如果你项目中有Newtonsoft.Json可以不用安装

一.Redis配置类(RedisConfig.cs)，用于配置Redis的参数

using System.Configuration;

namespace RedisDemo.Common
{
    public static class RedisConfig
    {
        private static string _Password = string.Empty;
        /// <summary>
        /// 密码
        /// </summary>
        public static string Password
        {
            get
            {
                if (string.IsNullOrEmpty(_Password))
                {
                    _Password = GetAppWebConfig("RedisPassword");
                }
                return _Password;
            }
        }

        private static string _IP = string.Empty;
        /// <summary>
        /// IP地址
        /// </summary>
        public static string IP
        {
            get
            {
                if (string.IsNullOrEmpty(_IP))
                {
                    _IP = GetAppWebConfig("RedisIP");
                }
                return _IP;
            }
        }

        private static int _Port = 0;
        /// <summary>
        /// 端口号
        /// </summary>
        public static int Port
        {
            get
            {
                if (_Port == 0)
                {
                    _Port = ParseInt(GetAppWebConfig("RedisPort"), 6379);
                }
                return _Port;
            }
        }

        private static int _Timeout = 0;
        /// <summary>
        /// 链接超时时间
        /// </summary>
        public static int Timeout
        {
            get
            {
                if (_Timeout == 0)
                {
                    _Timeout = ParseInt(GetAppWebConfig("RedisTimeout"), 10000);
                }
                return _Timeout;
            }
        }

        private static int _Retry = 0;
        /// <summary>
        /// 重试次数
        /// </summary>
        public static int Retry
        {
            get
            {
                if (_Retry == 0)
                {
                    _Retry = ParseInt(GetAppWebConfig("RedisRetry"), 3);
                }
                return _Retry;
            }
        }

        private static int _DefaultDB = -1;
        /// <summary>
        /// 默认使用的数据库(0 - 15)
        /// </summary>
        public static int DefaultDB
        {
            get
            {
                if (_DefaultDB == -1)
                {
                    _DefaultDB = ParseInt(GetAppWebConfig("RedisDefaultDB"), 0);
                }
                return _DefaultDB;
            }
        }


        /// <summary>
        /// 根据键名获取web.config/appsettings的值
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static string GetAppWebConfig(string key)
        {
            string text = ConfigurationManager.AppSettings[key];
            return (text != null) ? text : string.Empty;
        }

        /// <summary>
        /// Int类型转换
        /// </summary>
        /// <param name="o">需要被转换的值</param>
        /// <param name="defaultVal">转换失败后的默认值</param>
        /// <returns></returns>
        public static int ParseInt(object o, int defaultVal)
        {
            int result;
            if (o == null)
            {
                result = defaultVal;
            }
            else
            {
                string s = o.ToString();
                int num;
                if (!int.TryParse(s, out num))
                {
                    num = defaultVal;
                }
                result = num;
            }
            return result;
        }
    }
}

二.Redis连接管理类(RedisManager.cs)

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.IO;
using System.Text;
using System.Web;

namespace RedisDemo.Common
{
    public class RedisManager
    {
        private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            var configurationOptions = new ConfigurationOptions()
            {
                Password = RedisConfig.Password,
                EndPoints = { { RedisConfig.IP, RedisConfig.Port } },
                DefaultDatabase = RedisConfig.DefaultDB,
                ConnectTimeout = RedisConfig.Timeout,
                ConnectRetry = RedisConfig.Retry,
                AbortOnConnectFail = false
            };
            return ConnectionMultiplexer.Connect(configurationOptions);
        });

        public static ConnectionMultiplexer Connection
        {
            get
            {
                return lazyConnection.Value;
            }
        }


        /// <summary>
        /// Redis连接失败事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            var faildObj = new
            {
                EndPoint = e.EndPoint.ToString(),
                FailureType = e.FailureType.ToString(),
                Message = e.Exception == null ? "" : e.Exception.Message
            };
            string logText = string.Format(LOG_ERROR_TEMPLATE, DateTime.Now, "Redis连接失败", JsonConvert.SerializeObject(faildObj));
            WriteRedisErrorLog(logText);
        }

        private static void WriteRedisErrorLog(string Content)
        {
            DateTime logDate = DateTime.Now;
            string logPath = "~/Log/RedisError/";
            string logFilePath = GetMapPath(logPath + logDate.ToString("yyyy") + "/" + logDate.ToString("MM") + "/" + logDate.ToString("yyyyMMdd") + ".log");
            WriteFile(logFilePath, Content, true);
        }


        private const string LOG_ERROR_TEMPLATE = "**************** {0} ****************
"
                                                + "类型：{1}

"
                                                + "消息：{2}





";

        private static void WriteFile(string file, string fileContent, bool Append)
        {
            FileInfo fileInfo = new FileInfo(file);
            if (!Directory.Exists(fileInfo.DirectoryName))
            {
                Directory.CreateDirectory(fileInfo.DirectoryName);
            }
            StreamWriter streamWriter = new StreamWriter(file, Append, Encoding.UTF8);
            try
            {
                streamWriter.Write(fileContent);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
            finally
            {
                streamWriter.Flush();
                streamWriter.Close();
            }
        }

        public static string GetMapPath(string strPath)
        {
            string result;
            if (HttpContext.Current != null)
            {
                result = HttpContext.Current.Server.MapPath(strPath);
            }
            else
            {
                result = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath.TrimStart('~', '/'));
            }
            return result;
        }
    }
}

三.Redis操作类(RedisBase.cs)

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;

namespace RedisDemo.Common
{
    public class RedisBase
    {
        IDatabase db;

        public RedisBase()
        {
            db = RedisManager.Connection.GetDatabase();
        }

        /// <summary>
        /// 构造函数,用于操作其他db
        /// </summary>
        /// <param name="dbNumber"></param>
        public RedisBase(int dbNumber)
        {
            db = RedisManager.Connection.GetDatabase(dbNumber);
        }


        /// <summary>
        /// 设置String类型Redis缓存
        /// </summary>
        /// <param name="key">关键字</param>
        /// <param name="value">String字符串</param>
        /// <param name="expiry">过期时间</param>
        /// <returns></returns>
        public bool SetString(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        {
            return db.StringSet(key, value, expiry);
        }

        /// <summary>
        /// 获取String类型Redis缓存
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string GetString(string key)
        {
            return db.StringGet(key);
        }

        /// <summary>
        /// 设置单个对象Redis缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public bool SetObject<T>(string key, T value, TimeSpan? expiry = default(TimeSpan?)) where T : class
        {
            return SetString(key, JsonConvert.SerializeObject(value), expiry);
        }

        /// <summary>
        /// 获取单个对象Redis缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T GetObject<T>(string key) where T : class
        {
            string value = GetString(key);
            if (string.IsNullOrEmpty(value))
            {
                return null;
            }
            return JsonConvert.DeserializeObject<T>(value);
        }


        /// <summary>
        /// 插入List集合对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public bool SetList<T>(string key, List<T> value, TimeSpan? expiry = default(TimeSpan?))
        {
            return SetString(key, JsonConvert.SerializeObject(value), expiry);
        }

        /// <summary>
        /// 获取List集合对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> GetList<T>(string key)
        {
            return JsonConvert.DeserializeObject<List<T>>(GetString(key));
        }

        /// <summary>
        /// 删除单个Key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Remove(string key)
        {
            return db.KeyDelete(key);
        }

        /// <summary>
        /// 删除多个key
        /// </summary>
        /// <param name="keys"></param>
        public long RemoveAll(RedisKey[] keys)
        {
            return db.KeyDelete(keys);
        }


        /// <summary>
        /// 判断key是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool ContainsKey(string key)
        {
            return db.KeyExists(key);
        }

        /// <summary>
        /// 重新命名key
        /// </summary>
        /// <param name="key"></param>
        /// <param name="newKey"></param>
        /// <returns></returns>
        public bool KeyRename(string key, string newKey)
        {
            if (!this.ContainsKey(key))
            {
                return false;
            }
            return db.KeyRename(key, newKey);
        }

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

        public bool IsConnected(RedisKey key)
        {
            return db.IsConnected(key, CommandFlags.None);
        }
    }
}

作者：黄昌
出处：http://www.cnblogs.com/h-change/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利。