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 = ;
         /// <summary>
         /// 端口号
         /// </summary>
         public static int Port
         {
             get
             {
                 if (_Port == )
                 {
                     _Port = ParseInt(GetAppWebConfig("RedisPort"), );
                 }
                 return _Port;
             }
         }

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

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

         private static int _DefaultDB = -;
         /// <summary>
         /// 默认使用的数据库(0 - 15)
         /// </summary>
         public static int DefaultDB
         {
             get
             {
                 if (_DefaultDB == -)
                 {
                     _DefaultDB = ParseInt(GetAppWebConfig("RedisDefaultDB"), );
                 }
                 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} ****************\r\n"
                                                 + "类型：{1}\r\n\r\n"
                                                 + "消息：{2}\r\n\r\n\r\n\r\n\r\n\r\n";

         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/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利。