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 = 10000;
            clientConfig.MaxReadPoolSize = 10000;
            clientConfig.AutoStart = true;
            clientConfig.DefaultDb = DbIndex;
            PooledRedisClientManager clientManager = new PooledRedisClientManager(readWriteHosts, readOnlyHosts, clientConfig);
            return clientManager;
        }

        /// <summary>
        /// 是否使用緩存開關
        /// </summary>
        private static bool IsOpenCache
        {
            get
            {
                if (isOpenCache != 1) 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(24));
                        }
                    }
                    else
                    {
                        using (IRedisClient Redis = prcm.GetClient())
                        {
                            result = Redis.Set<byte[]>(key, SetBytesFormT(value), DateTime.Now.AddHours(24));
                        }
                    }
                }
            }
            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(24));
                        }
                    }
                }
            }
            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(24));
                        }
                    }
                    else
                    {
                        using (IRedisClient Redis = prcm.GetClient())
                        {
                            result = Redis.Set<byte[]>(key, SetBytesFormT(value), DateTime.Now.AddHours(24));
                        }
                    }
                }
            }
            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 = 0;
                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