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

         }

     }

 }