C# ASP.NET常见4种页面缓存方式

Biegral 2019/2/4 2:03:22 2922

1、分布式缓存Memcached教程pdf下载
2、内存缓存,此暂用服务器资源，没钱买好机机的少用，不用！
view plainprint?
  1. #region 内存缓存  
  2.         public class MemoryCache  
  3.         {  
  4.             #region 写  
  5.             /// <summary>  
  6.             /// 向内存写入数据缓存  
  7.             /// </summary>  
  8.             /// <remarks>TOMMYHU2011-7-28 10:25创建</remarks>  
  9.             /// <param name="cachekey">缓存标识关键字</param>  
  10.             /// <param name="cacheresult">需要存放的数据</param>  
  11.             /// <param name="cachetime">单位秒</param>  
  12.             public static void InertMemoryCache(string cachekey, object cacheresult, int cachetime)  
  13.             {  
  14.                 if (cacheresult != null)  
  15.                 {  
  16.                     System.Web.HttpRuntime.Cache.Insert(cachekey, cacheresult, null  
  17.                         , System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromSeconds(cachetime));  
  18.                 }  
  19.             }  
  20.             #endregion  
  21.             #region 读  
  22.             /// <summary>  
  23.             /// 根据缓存标识读取内存缓存信息  
  24.             /// </summary>  
  25.             /// <remarks>TOMMYHU2011-7-28 10:25创建</remarks>  
  26.             /// <param name="cachekey">缓存标识关键字</param>  
  27.             /// <returns>内存缓存数据</returns>  
  28.             public static object ReadMemoryCache(string cachekey)  
  29.             {  
  30.                 object obj = System.Web.HttpRuntime.Cache.Get(cachekey);  
  31.                 if (obj != null)  
  32.                 {  
  33.                     return obj;  
  34.                 }  
  35.                 return null;  
  36.             }  
  37.             #endregion  
  38.         }   
  39.         #endregion  

3、XML缓存，这种最为常见
view plainprint?
  1.         #region xml缓存  
  2.         public static class XmlCache  
  3.         {  
  4.             private static string m_CacheFolderName = null;  
  5.   
  6.             #region 获取/生成缓存文件方法(无cmdParams)  
  7.             /// <summary>  
  8.             /// 获取/生成缓存文件方法(DataTable)  
  9.             /// </summary>  
  10.             /// <param name="SQL">用于将Sql转化为MD5字符串</param>  
  11.             /// <param name="CacheFilePath">存放Xml文件的相对路径(根目录已预置)</param>  
  12.             /// <param name="CacheTime">缓存时间</param>  
  13.             /// <param name="DataUsed">使用的数据库的链接字符串</param>  
  14.             /// <returns></returns>  
  15.             public static DataTable CacheFileByDataTable(string SQL, string CacheFilePath, int CacheTime)  
  16.             {  
  17.                 SQLHelper.SQLHelper QuerySql = new SQLHelper.SQLHelper();  
  18.                 if (CacheFilePath != string.Empty && CacheFilePath.StartsWith("/"))  
  19.                 {  
  20.                     CacheFilePath = CacheFilePath.Remove(0, 1);  
  21.                 }  
  22.   
  23.                 string SqlMd5 = SQL;//用于将Sql转化为MD5字符串  
  24.   
  25.                 string StrSqlByMd5 = System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(SqlMd5, "MD5");//生成的Md5文件名  
  26.   
  27.                 string MyCacheFilePath = "";  
  28.   
  29.                 if (CacheTime >= 10000)//如果大于20天的话系统默认为持久  
  30.                 {  
  31.                     MyCacheFilePath = XmlCache.CacheFolderNameP + CacheFilePath;//用于存放Xml文件的相对路径  
  32.                 }  
  33.                 else  
  34.                 {  
  35.                     MyCacheFilePath = XmlCache.CacheFolderName + CacheFilePath;//用于存放Xml文件的相对路径  
  36.                 }  
  37.   
  38.   
  39.                 int MyCacheTime = CacheTime;//缓存时间(分)  
  40.   
  41.                 DataTable dt = new DataTable();//存放数据记录的DataTable  
  42.   
  43.                 DataTable CacheDt = new DataTable();//获取缓存数据记录的DataTable  
  44.   
  45.   
  46.                 //尝试获取缓存数据记录  
  47.                 try  
  48.                 {  
  49.                     CacheDt = DataTableCache.GetDTCache(MyCacheTime, MyCacheFilePath, StrSqlByMd5);  
  50.                 }  
  51.                 catch  
  52.                 {  
  53.                     CacheDt = null;  
  54.                 }  
  55.                 if (CacheDt != null)//获取到缓存的XML文件  
  56.                 {  
  57.                     dt = CacheDt;  
  58.                 }  
  59.                 else//未获取到缓存的XML文件  
  60.                 {  
  61.                     //生成DataTable(如果用Query查询请用Query.ProcessSql方法)  
  62.                     //dt = Query.ProcessSql(SqlMd5, DataUsed);  
  63.                     dt = QuerySql.retDT(SQL);  
  64.   
  65.                     //将DataTable存为XML文件  
  66.                     try  
  67.                     {  
  68.                         if (dt.DataSet != null)  
  69.                         {  
  70.                             dt.DataSet.Tables.Remove(dt);  
  71.                         }  
  72.   
  73.                         DataTableCache.SetDTCache(MyCacheFilePath, StrSqlByMd5, dt);  
  74.                     }  
  75.                     catch (Exception ex)  
  76.                     {  
  77.                         //Log.GetComLogger().Error("将DataTable存为XML文件出错：" + ex.Message);  
  78.                     }  
  79.                 }  
  80.                 return dt;  
  81.             }  
  82.   
  83.             /// <summary>  
  84.             /// 获取/生成缓存文件方法(DataSet) Add By WJ 08-10-23  
  85.             /// </summary>  
  86.             /// <param name="SQL">用于将Sql转化为MD5字符串</param>  
  87.             /// <param name="CacheFilePath">存放Xml文件的相对路径(根目录已预置)</param>  
  88.             /// <param name="CacheTime">缓存时间</param>  
  89.             /// <param name="DBName">使用的数据库的链接字符串</param>  
  90.             /// <returns></returns>  
  91.             public static DataSet CacheFileByDataSet(string SQL, string CacheFilePath, int CacheTime)  
  92.             {  
  93.                 SQLHelper.SQLHelper QuerySql = new SQLHelper.SQLHelper();  
  94.                 if (CacheFilePath != string.Empty && CacheFilePath.StartsWith("/"))  
  95.                 {  
  96.                     CacheFilePath = CacheFilePath.Remove(0, 1);  
  97.                 }  
  98.   
  99.                 string SqlMd5 = SQL;//用于将Sql转化为MD5字符串  
  100.   
  101.                 string StrSqlByMd5 = System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(SqlMd5, "MD5");//生成的Md5文件名  
  102.   
  103.                 string MyCacheFilePath = XmlCache.CacheFolderName + CacheFilePath;//用于存放Xml文件的相对路径  
  104.   
  105.                 int MyCacheTime = CacheTime;//缓存时间(分)  
  106.   
  107.                 DataSet ds = new DataSet();//存放数据记录的DataSet  
  108.   
  109.                 DataSet CacheDs = new DataSet();//获取缓存数据记录的DataSet  
  110.   
  111.                 //尝试获取缓存数据记录  
  112.                 try  
  113.                 {  
  114.                     CacheDs = DataTableCache.GetDSCache(MyCacheTime, MyCacheFilePath, StrSqlByMd5);  
  115.                 }  
  116.                 catch  
  117.                 {  
  118.                     CacheDs = null;  
  119.                 }  
  120.                 if (CacheDs != null)//获取到缓存的XML文件  
  121.                 {  
  122.                     ds = CacheDs;  
  123.                 }  
  124.                 else//未获取到缓存的XML文件  
  125.                 {  
  126.                     //生成DataSet  
  127.                     //ds = Query.ProcessMultiSql(SqlMd5, DBName);  
  128.                     ds = QuerySql.retDS(SQL);  
  129.   
  130.                     //将DataSet存为XML文件  
  131.                     try  
  132.                     {  
  133.                         DataTableCache.SetDSCache(MyCacheFilePath, StrSqlByMd5, ds);  
  134.                     }  
  135.                     catch  
  136.                     { }  
  137.                 }  
  138.                 return ds;  
  139.             }  
  140.   
  141.             #endregion  
  142.   
  143.             #region 获取/生成缓存文件方法(有cmdParams)  
  144.             /// <summary>  
  145.             /// 获取/生成缓存文件方法(DataTable)  
  146.             /// </summary>  
  147.             /// <param name="SQL">用于将Sql转化为MD5字符串</param>  
  148.             /// <param name="CacheFilePath">存放Xml文件的相对路径(根目录已预置)</param>  
  149.             /// <param name="CacheTime">缓存时间</param>  
  150.             /// <param name="DataUsed">使用的数据库的链接字符串</param>  
  151.             /// <param name="cmdParams">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  152.             /// <returns></returns>  
  153.             public static DataTable CacheFileByDataTable(string SQL, string CacheFilePath, int CacheTime, string DBConstr, params SqlParameter[] cmdParams)  
  154.             {  
  155.                 SQLHelper.SQLHelper QuerySql = new SQLHelper.SQLHelper();  
  156.                 if (CacheFilePath != string.Empty && CacheFilePath.StartsWith("/"))  
  157.                 {  
  158.                     CacheFilePath = CacheFilePath.Remove(0, 1);  
  159.                 }  
  160.   
  161.                 string SqlMd5 = SQL;//用于将Sql转化为MD5字符串  
  162.   
  163.                 string sqlmd5params = SQL;  
  164.                 if (cmdParams != null)  
  165.                 {  
  166.                     for (int i = 0; i < cmdParams.Length; i++)  
  167.                     {  
  168.                         if (cmdParams[i].Value != null)  
  169.                             sqlmd5params += cmdParams[i].Value.ToString();  
  170.                     }  
  171.                 }  
  172.   
  173.                 string StrSqlByMd5 = System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sqlmd5params, "MD5");//生成的Md5文件名  
  174.   
  175.                 string MyCacheFilePath = "";  
  176.   
  177.                 if (CacheTime >= 10000)//如果大于20天的话系统默认为持久  
  178.                 {  
  179.                     MyCacheFilePath = XmlCache.CacheFolderNameP + CacheFilePath;//用于存放Xml文件的相对路径  
  180.                 }  
  181.                 else  
  182.                 {  
  183.                     MyCacheFilePath = XmlCache.CacheFolderName + CacheFilePath;//用于存放Xml文件的相对路径  
  184.                 }  
  185.   
  186.                 int MyCacheTime = CacheTime;//缓存时间(分)  
  187.   
  188.                 DataTable dt = new DataTable();//存放数据记录的DataTable  
  189.   
  190.                 DataTable CacheDt = new DataTable();//获取缓存数据记录的DataTable  
  191.   
  192.   
  193.                 //尝试获取缓存数据记录  
  194.                 CacheDt = DataTableCache.GetDTCache(MyCacheTime, MyCacheFilePath, StrSqlByMd5);  
  195.   
  196.                 if (CacheDt != null)//获取到缓存的XML文件  
  197.                 {  
  198.                     dt = CacheDt;  
  199.                 }  
  200.                 else//未获取到缓存的XML文件  
  201.                 {  
  202.                     //生成DataTable(如果用Query查询请用Query.ProcessSql方法)  
  203.                     //dt = Query.ProcessSql(SqlMd5, DataUsed);  
  204.                     dt = QuerySql.retDT(SqlMd5);  
  205.                     DataTable dt1 = new DataTable();  
  206.                     if (dt != null)  
  207.                     {  
  208.                         dt1 = dt.Copy();  
  209.                     }  
  210.                     //将DataTable存为XML文件  
  211.                     DataTableCache.SetDTCache(MyCacheFilePath, StrSqlByMd5, dt1);  
  212.                 }  
  213.                 return dt;  
  214.             }  
  215.   
  216.   
  217.             /// <summary>  
  218.             /// 获取/生成缓存文件方法(DataSet) Add By wjf  
  219.             /// </summary>  
  220.             /// <param name="SQL">用于将Sql转化为MD5字符串</param>  
  221.             /// <param name="CacheFilePath">存放Xml文件的相对路径(根目录已预置)</param>  
  222.             /// <param name="CacheTime">缓存时间</param>  
  223.             /// <param name="DBName">使用的数据库的链接字符串</param>  
  224.             /// <param name="cmdParams">以数组形式提供SqlCommand命令中用到的参数列表</param>  
  225.             /// <returns></returns>  
  226.             public static DataSet CacheFileByDataSet(string SQL, string CacheFilePath, int CacheTime, string DBConstr, params SqlParameter[] cmdParams)  
  227.             {  
  228.                 SQLHelper.SQLHelper QuerySql = new SQLHelper.SQLHelper();  
  229.                 string SqlMd5 = SQL;//用于将Sql转化为MD5字符串  
  230.   
  231.                 string sqlmd5params = SQL;  
  232.                 if (cmdParams != null)  
  233.                 {  
  234.                     for (int i = 0; i < cmdParams.Length; i++)  
  235.                     {  
  236.                         if (cmdParams[i].Value != null)  
  237.                             sqlmd5params += cmdParams[i].Value.ToString();  
  238.                     }  
  239.                 }  
  240.   
  241.                 string StrSqlByMd5 = System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sqlmd5params, "MD5");//生成的Md5文件名  
  242.   
  243.                 string MyCacheFilePath = XmlCache.CacheFolderName + CacheFilePath;//用于存放Xml文件的相对路径  
  244.   
  245.                 int MyCacheTime = CacheTime;//缓存时间(分)  
  246.   
  247.                 DataSet ds = new DataSet();//存放数据记录的DataSet  
  248.   
  249.                 DataSet CacheDs = new DataSet();//获取缓存数据记录的DataSet  
  250.   
  251.                 //尝试获取缓存数据记录  
  252.                 CacheDs = DataTableCache.GetDSCache(MyCacheTime, MyCacheFilePath, StrSqlByMd5);  
  253.   
  254.                 if (CacheDs != null)//获取到缓存的XML文件  
  255.                 {  
  256.                     ds = CacheDs;  
  257.                 }  
  258.                 else//未获取到缓存的XML文件  
  259.                 {  
  260.                     //生成DataSet  
  261.                     //ds = Query.ProcessMultiSql(SqlMd5, DBName);  
  262.                     ds = QuerySql.retDS(SqlMd5);  
  263.                     DataSet ds1 = new DataSet();  
  264.                     if (ds != null)  
  265.                     {  
  266.                         ds1 = ds.Copy();  
  267.                     }  
  268.                     //将DataSet存为XML文件  
  269.                     DataTableCache.SetDSCache(MyCacheFilePath, StrSqlByMd5, ds1);  
  270.                 }  
  271.                 return ds;  
  272.             }  
  273.             #endregion  
  274.   
  275.             #region 非持久保持  
  276.             /// <summary>  
  277.             /// 非持久保持  
  278.             /// </summary>  
  279.             public static string CacheFolderName  
  280.             {  
  281.                 get  
  282.                 {  
  283.                     if (m_CacheFolderName == null)//如果Global.asax中未定义路径  
  284.                     {  
  285.                         m_CacheFolderName = System.Configuration.ConfigurationManager.AppSettings.GetValues("CachePathRoot")[0];  
  286.                         if (m_CacheFolderName == null)//如果Web.Config中未定义路径  
  287.                         {  
  288.                             return "/CacheData/" + DateTime.Now.ToString("yyyyMMdd") + "/";  
  289.                         }  
  290.                         else  
  291.                         {  
  292.                             return m_CacheFolderName  + DateTime.Now.ToString("yyyyMMdd") + "/";  
  293.                         }  
  294.                     }  
  295.                     else  
  296.                     {  
  297.                         return m_CacheFolderName  + DateTime.Now.ToString("yyyyMMdd") + "/";  
  298.                     }  
  299.                 }  
  300.   
  301.                 set  
  302.                 {  
  303.                     m_CacheFolderName = value;  
  304.                 }  
  305.             }  
  306.             #endregion  
  307.   
  308.             #region 持久保存(例如存放MapBar缓存的数据或需要3个月以上更新的数据等)  
  309.             /// <summary>  
  310.             /// 持久保存(例如存放MapBar缓存的数据或需要3个月以上更新的数据等)  
  311.             /// </summary>  
  312.             public static string CacheFolderNameP  
  313.             {  
  314.                 get  
  315.                 {  
  316.                     if (m_CacheFolderName == null)//如果Global.asax中未定义路径  
  317.                     {  
  318.                         m_CacheFolderName = System.Configuration.ConfigurationManager.AppSettings.GetValues("CachePathRoot")[0];  
  319.                         if (m_CacheFolderName == null)//如果Web.Config中未定义路径  
  320.                         {  
  321.                             return "/CacheData/";  
  322.                         }  
  323.                         else  
  324.                         {  
  325.                             return m_CacheFolderName;  
  326.                         }  
  327.                     }  
  328.                     else  
  329.                     {  
  330.                         return m_CacheFolderName;  
  331.                     }  
  332.                 }  
  333.   
  334.                 set  
  335.                 {  
  336.                     m_CacheFolderName = value;  
  337.                 }  
  338.             }  
  339.             #endregion  
  340.         }  
  341.         #endregion  

4、DATATABLE缓存
本文转载:CSDN博客

阅读排行

分类

归档