Redis 通用方法 存储DataTable DataRow DataSet

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Web;
 using ServiceStack.Redis;
 using System.Data;

 namespace Utils
 {
     public static class HttpCache<T>
     {
         #region Redis
         //redis IP地址
         private static string RedisIP = System.Configuration.ConfigurationSettings.AppSettings["RedisIP"];
         //redis密码（不填表示没有密码）
         private static string RedisPassword = System.Configuration.ConfigurationSettings.AppSettings["RedisPassword"];
         //redis端口（不填默认6379）
         private static int RedisPort = Convert.ToInt32(System.Configuration.ConfigurationSettings.AppSettings["RedisPort"]);
         //redis库索引号（整数，默认有5个库，从0开始，不填表示0）
         private static int DbIndex = Convert.ToInt32(System.Configuration.ConfigurationSettings.AppSettings["RedisDbIndex"]);
         //redis 是否使用缓存开关
         private static int isOpenCache = Convert.ToInt32(System.Configuration.ConfigurationSettings.AppSettings["IsOpenRedis"]);

         private static PooledRedisClientManager prcm = CreateManager(
         new string[] { (RedisPassword.Trim() == string.Empty ? "" : RedisPassword + "@") + RedisIP + ":" + RedisPort + " " },
         new string[] { (RedisPassword.Trim() == string.Empty ? "" : RedisPassword + "@") + RedisIP + ":" + RedisPort + " " });
         private static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
         {
             // 支持读写分离，均衡负载
             RedisClientManagerConfig clientConfig = new RedisClientManagerConfig();

             clientConfig.MaxWritePoolSize = ;
             clientConfig.MaxReadPoolSize = ;
             clientConfig.AutoStart = true;
             clientConfig.DefaultDb = DbIndex;
             PooledRedisClientManager clientManager = new PooledRedisClientManager(readWriteHosts, readOnlyHosts, clientConfig);
             return clientManager;
         }

         /// <summary>
         /// 是否使用缓存开关
         /// </summary>
         private static bool IsOpenCache
         {
             get
             {
                 if (isOpenCache != ) return false;
                 return true;
             }
         }

         /// <summary>
         /// 加入缓存
         /// </summary>
         /// <typeparam name="T">对象类型</typeparam>
         /// <param name="key">Key(键值命名规范：RK_字段名_表名_条件字段1_值_条件字段n_值......,键值全部小写,表名不加dbo前缀)</param>
         /// <param name="value">对象</param>
         /// <param name="Timer">缓存时间(除了XianZhiAccounts的过期时间为一小时，其余的过期时间都为两天)</param>
         /// <returns>是否缓存成功</returns>
         /// 对于datatable 的缓存 需要特殊处理
         public static bool SaveCaChe(string key, T value)
         {
             bool result = false;
             try
             {
                 if (IsOpenCache)
                 {
                     if (!(value is DataTable) && !(value is DataSet) && !(value is DataRow))
                     {
                         using (IRedisClient Redis = prcm.GetClient())
                         {
                             result = Redis.Set<T>(key, value, DateTime.Now.AddHours());
                         }
                     }
                     else
                     {
                         using (IRedisClient Redis = prcm.GetClient())
                         {
                             result = Redis.Set<byte[]>(key, SetBytesFormT(value), DateTime.Now.AddHours());
                         }
                     }
                 }
             }
             catch { }
             return result;
         }
         public static bool SaveCaChe(string key, T value, int Timer)
         {
             bool result = false;
             try
             {
                 if (IsOpenCache)
                 {
                     if (!(value is DataTable) && !(value is DataSet) && !(value is DataRow))
                     {
                         using (IRedisClient Redis = prcm.GetClient())
                         {
                             result = Redis.Set<T>(key, value, TimeSpan.FromMinutes(Timer));
                         }
                     }
                     else
                     {
                         using (IRedisClient Redis = prcm.GetClient())
                         {
                             result = Redis.Set<byte[]>(key, SetBytesFormT(value), DateTime.Now.AddHours());
                         }
                     }
                 }
             }
             catch { }
             return result;
         }
         public static bool SaveBaseCaChe(string key, T value)
         {
             bool result = false;
             try
             {
                 if (IsOpenCache)
                 {
                     if (!(value is DataTable) && !(value is DataSet) && !(value is DataRow))
                     {
                         using (IRedisClient Redis = prcm.GetClient())
                         {
                             result = Redis.Set<T>(key, value, DateTime.Now.AddHours());
                         }
                     }
                     else
                     {
                         using (IRedisClient Redis = prcm.GetClient())
                         {
                             result = Redis.Set<byte[]>(key, SetBytesFormT(value), DateTime.Now.AddHours());
                         }
                     }
                 }
             }
             catch { }
             return result;
         }
         public static bool SaveBaseCaChe(string key, T value, int Timer)
         {
             bool result = false;
             try
             {
                 if (IsOpenCache)
                 {
                     if (!(value is DataTable) && !(value is DataSet) && !(value is DataRow))
                     {
                         using (IRedisClient Redis = prcm.GetClient())
                         {
                             result = Redis.Set<T>(key, value, TimeSpan.FromMinutes(Timer));
                         }
                     }
                     else
                     {
                         using (IRedisClient Redis = prcm.GetClient())
                         {
                             result = Redis.Set<byte[]>(key, SetBytesFormT(value), TimeSpan.FromMinutes(Timer));
                         }
                     }
                 }
             }
             catch { }
             return result;
         }

         /// <summary>
         /// 获取缓存内容
         /// </summary>
         /// <param name="key">Key</param>
         /// <returns></returns>
         public static T GetCaChe(string key)
         {
             try
             {
                 if (!IsOpenCache) return default(T);
                 using (IRedisClient Redis = prcm.GetClient())
                 {
                     return Redis.Get<T>(key);
                 }
             }
             catch
             {
                 string str = string.Empty;
                 return default(T);
             }
         }
         public static T GetBaseCaChe(string key)
         {
             try
             {
                 if (!IsOpenCache) return default(T);
                 using (IRedisClient Redis = prcm.GetClient())
                 {
                     return Redis.Get<T>(key);
                 }
             }
             catch
             {
                 string str = string.Empty;
                 return default(T);
             }
         }
         /// <summary>
         /// 对于datatable 的缓存 需要特殊处理
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <returns></returns>
         public static T GetBaseCaChe<T>(string key) where T : class
         {
             try
             {
                 if (!IsOpenCache) return default(T);
                 if (!(typeof(T).ToString() == "System.Data.DataTable")
                     && !(typeof(T).ToString() == "System.Data.DataSet")
                     && !(typeof(T).ToString() == "System.Data.DataRow"))
                 {
                     using (IRedisClient Redis = prcm.GetClient())
                     {
                         return Redis.Get<T>(key);
                     }
                 }
                 else
                 {
                     using (IRedisClient Redis = prcm.GetClient())
                     {
                         byte[] buffer = Redis.Get<byte[]>(key);
                         return GetObjFromBytes(buffer) as T;
                     }
                 }
             }
             catch
             {
                 string str = string.Empty;
                 return default(T);
             }
         }

         /// <summary>
         /// 删除缓存
         /// </summary>
         /// <param name="key">Key</param>
         /// <returns></returns>
         public static bool DeleteCache(string key)
         {
             try
             {
                 if (!IsOpenCache) return false;
                 using (IRedisClient Redis = prcm.GetClient())
                 {
                     return Redis.Remove(key);
                 }
             }
             catch { return false; }
         }

         /// <summary>
         /// 批量删除缓存
         /// </summary>
         /// <param name="keys">Key</param>
         /// <returns></returns>
         public static void DeleteCache(List<string> keys)
         {
             try
             {
                 if (!IsOpenCache) return;
                 using (IRedisClient Redis = prcm.GetClient())
                 {
                     Redis.RemoveAll(keys);
                 }
             }
             catch { return; }
         }

         /// <summary>
         /// 清空缓存
         /// </summary>
         public static void ClearCache()
         {
             try
             {
                 if (!IsOpenCache) return;
                 using (IRedisClient Redis = prcm.GetClient())
                 {
                     Redis.FlushAll();
                 }
             }
             catch { return; }
         }
         /// <summary>
         /// 是否包含KEY缓存
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
         public static bool IsContain(string key)
         {
             try
             {
                 if (!IsOpenCache) return false;
                 using (IRedisClient Redis = prcm.GetClient())
                 {
                     return Redis.ContainsKey(key);
                 }
             }
             catch { return false; }
         }

         public static byte[] SetBytesFormT(T t)
         {
             System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();//定义BinaryFormatter以序列化DataSet对象
             System.IO.MemoryStream ms = new System.IO.MemoryStream();//创建内存流对象
             formatter.Serialize(ms, t);//把DataSet对象序列化到内存流
             byte[] buffer = ms.ToArray();//把内存流对象写入字节数组
             ms.Close();//关闭内存流对象
             ms.Dispose();//释放资源
             return buffer;
         }

         private static object GetObjFromBytes(byte[] buffer)
         {
             using (System.IO.MemoryStream stream = new System.IO.MemoryStream(buffer))
             {
                 stream.Position = ;
                 System.Runtime.Serialization.IFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                 Object reobj = bf.Deserialize(stream);
                 return reobj;
             }
         }
         #endregion
     }
 }

公司统一走redis缓存，也将之前的memcache迁移到redis
碰到问题是redis的dataset缓存。

memcache底层封装了dataset的序列化。

而redis引的DLL包，未支持。所以封装一个类，提供dataset的set,get功能。

dataset以转为byte[]保存，读取byte[] 转为dataset