[转]文件缓存的方式减少网站负载

Asp.net 缓存Cache功能已经是很常见的功能了，网络上面这种相关的文章也非常之多，我这里所要讲的缓存并不是.NET所提供的缓存，而是过通文件方式来存放的。这样可以很好的减少服务器资源。
先看一下我做这个的缓存流程图：




如上图所示，其实程序就是在Page_Load的时候做一下判断，是否有缓存文件存在或者缓存是否过期（过期的判断是通过文件的最后修改日期来处理的），如果没有，它将会去读取当前页的页面HTML代码，并用当前页的文件名保存成一个文件缓存。下次再打开此页的时候就会去读取存下来的缓存文件的内容，并同时中断PageLoad后边的方式，从页实现很有效的使用很方便的缓存机制。

以下是部分代码
default.aspx.cs (一个普通的服务端页面)

using  System;
using  System.Collections;
using  System.ComponentModel;
using  System.Data;
using  System.Drawing;
using  System.Web;
using  System.Web.SessionState;
using  System.Web.UI;
using  System.Web.UI.WebControls;
using  System.Web.UI.HtmlControls;

namespace  cacheweb
{
     ///   <summary>
     ///  _default 的摘要说明。
     ///   </summary>
     public   class  _default : BasePage
    {
         private   void  Page_Load( object  sender, System.EventArgs e)
        {
             //  在此处放置用户代码以初始化页面
             if ( this .FileCacheProgress())
            {
                 return  ;
            }

            initPage();
        }

         private   void  initPage()
        {            
            Response.Write( " FileCache V0.1 - 文件缓存方式的功能演示<br /> " );
            Response.Write( " Wathon Team<br /> " );
            Response.Write( " <a href=\ " http: // www.wathon.com\"> http://www.wathon.com </a><br />");
            Response.Write( " <a href=\ " http: // www.cnblogs.com/huacn/archive/2007/11/07/aspnet_page_cache_file.html\">参数讨论</a><br />");
            Response.Write( " 以下是上次缓存的时间：<br /> " );
            Response.Write(DateTime.Now.ToLocalTime() + " <br /> " );
            Response.Write(DateTime.Now.ToLongDateString() + " <br /> " );
            Response.Write(DateTime.Now.ToLongTimeString() + " <br /> " );
            Response.Write(DateTime.Now.ToOADate() + " <br /> " );
            Response.Write(DateTime.Now.ToShortDateString() + " <br /> " );
            Response.Write(DateTime.Now.ToUniversalTime() + " <br /> " );
            Response.Write(DateTime.Now.ToShortTimeString() + " <br /> " );
        }

         #region  Web 窗体设计器生成的代码
         override   protected   void  OnInit(EventArgs e)
        {
             //
             //  CODEGEN: 该调用是 ASP.NET Web 窗体设计器所必需的。
             //
            InitializeComponent();
             base .OnInit(e);
        }
        
         ///   <summary>
         ///  设计器支持所需的方法 - 不要使用代码编辑器修改
         ///  此方法的内容。
         ///   </summary>
         private   void  InitializeComponent()
        {    
             this .Load  +=   new  System.EventHandler( this .Page_Load);
        }
         #endregion
    }
}

BasePage.cs (页面的基类)

using  System;
using  System.Web;
using  System.Web.UI;
using  System.Web.UI.WebControls;
using  System.Net;
using  System.Text;
using  System.IO;
using  cacheweb.App_code.FileCache;


///   <summary>
///  页面的基类
///  Wathon Team.
///  By Json Lee 2007-11-07
///   http://www.wathon.com
///   </summary>
public   class  BasePage:Page
{
     #region  缓存
     ///   <summary>
     ///  缓存处理
     ///   </summary>
     protected   bool  FileCacheProgress()
    {
         return  FileCacheProgress( false ,  true );
    }

     ///   <summary>
     ///  重写缓存
     ///   </summary>
     public   void  FileCacheRewrite()
    {
        FileCacheProgress( true ,  false );
    }

     ///   <summary>
     ///  缓存处理
     ///   </summary>
     ///   <param name="IsReCache"> true强行重写cache </param>
     ///   <param name="IsRewritePage"> 是否重写输入出页面内容 </param>
     ///   <returns></returns>
     private   bool  FileCacheProgress( bool  IsReCache, bool  IsRewritePage)
    {
        FileCaches filecaches  =   new  FileCaches();
         try
        {
            filecaches.FileCacheMiniutes  =   30 ;
            filecaches.FileExt  =   " .cache " ;
            filecaches.FileSavePath  =   @" D:\CacheFiles\Test " ;

             if  (filecaches.CacheProgress(HttpContext.Current, IsReCache, IsRewritePage))
            {
                 return   true ;
            }
        }
         catch  (Exception ex)
        {
             throw   new  Exception(ex.ToString());
        }

         return   false ;
    }
     #endregion

}

FileCaches.cs (Cache主要类)

using  System;
using  System.Web;
using  System.Text;
using  System.IO;
using  System.Net;

namespace  cacheweb.App_code.FileCache
{
     ///   <summary>
     ///  FileCache 文件缓存类 V0.2
     ///  Wathon Team
     ///   http://www.wathon.com
     ///   http://www.cnblogs.com/huacn/archive/2007/11/07/aspnet_page_cache_file.html
     ///   </summary>
     public   class  FileCaches : FileCacheBase
    {
         ///   <summary>
         ///  自动处理页面缓存
         ///  当返回true表示要中断页面的所有内容
         ///  false不要做处理
         ///  会重Response.Write
         ///   </summary>
         ///   <param name="httpcontext"> 请传入当前页的HttpContext </param>
         ///   <returns></returns>
         public   bool  CacheProgress(HttpContext httpcontext)
        {
             return   this .CacheProgress(httpcontext,  false , true );
        }

         ///   <summary>
         ///  自动处理页面缓存
         ///  当返回true表示要中断页面的所有内容
         ///  false不要做处理
         ///  会重Response.Write
         ///   </summary>
         ///   <param name="httpcontent"> 请传入当前页的HttpContext </param>
         ///   <param name="IsReCache"> 是否强制重写Cahce </param>
         ///   <returns></returns>
         public   bool  CacheProgress(HttpContext httpcontext,  bool  IsReCache)
        {
             return  CacheProgress(httpcontext, IsReCache,  true );
        }

         ///   <summary>
         ///  自动处理页面缓存
         ///  当返回true表示要中断页面的所有内容
         ///  false不要做处理
         ///   </summary>
         ///   <param name="httpcontent"> 请传入当前页的HttpContext </param>
         ///   <param name="IsReCache"> 是否强制重写Cahce </param>
         ///   <param name="IsRewritePage"> 是否重写页面内容 Response.Write 当为False时，只是重新生成静态文件，页面内容不会变动 </param>
         ///   <returns></returns>
         public   bool  CacheProgress(HttpContext httpcontext, bool  IsReCache, bool  IsRewritePage)
        {
             if  (httpcontext.Request.QueryString[ " serverget " ]  ==   " 1 " )
            {
                 return   false ;
            }

             string  strContent  =   "" ;
             string  strUrl  =  httpcontext.Request.Url.ToString();
             string  strDomain  =  httpcontext.Request.Url.Host;

             if  ( this .ExistCache(strUrl, strDomain)  ==   false   ||  IsReCache  ==   true )
            {
                 // 取当前页面的HTML
                strContent  =   this .GetUrlResponse(strUrl);
                strContent  +=   " \r\n<!-- FileCache By  "   +  DateTime.Now.ToUniversalTime()  +   "  --> " ;
                 // 存缓存
                 this .SetCache(strContent, strUrl, strDomain);
            }
             else
            {

                 // 取缓存
                strContent  =   this .GetCache(strUrl, strDomain);
            }


             // 输出内容,当是重写Cache
             if  (IsRewritePage)
            {
                httpcontext.Response.Write(strContent);
                httpcontext.Response.End();
            }
            
             return   true ;
        }




         ///   <summary>
         ///  保存Cache
         ///   </summary>
         ///   <param name="p_Content"></param>
         ///   <param name="p_Url"> 页面地址 </param>
         ///   <param name="p_Domain"> 域名 </param>
         public   void  SetCache( string  p_Content,  string  p_Url, string  p_Domain)
        {
             string  fileNameNoExt  =  GetFileNameNoExt(p_Url, p_Domain);
             // 写在这里            
             this .SaveFile(fileNameNoExt, p_Content);
        }

         ///   <summary>
         ///  检查Cache文件是否存在或过期
         ///   </summary>
         ///   <param name="p_Url"> 页面地址 </param>
         ///   <param name="p_Domain"> 域名 </param>
         ///   <returns></returns>
         public   bool  ExistCache( string  p_Url, string  p_Domain)
        {
             string  fileNameNoExt  =  GetFileNameNoExt(p_Url,p_Domain);

             return   this .ExistFile(fileNameNoExt);
        }

         ///   <summary>
         ///  取Cache,请在使用之间先用 ExistCache 确定Cache存在
         ///   </summary>
         ///   <param name="p_Url"> 页面地址 </param>
         ///   <param name="p_Domain"> 域名 </param>
         ///   <returns></returns>
         public   string  GetCache( string  p_Url,  string  p_Domain)
        {
             string  strContent  =   "" ;
             string  fileNameNoExt  =  GetFileNameNoExt(p_Url, p_Domain);
             this .ReadFile(fileNameNoExt,  ref  strContent);

             return  strContent;
        }
    }

     ///   <summary>
     ///  文件缓存基类
     ///  By Json Lee 2007-11-07
     ///   </summary>
     public   abstract   class  FileCacheBase 
    {
         #region  属性定义
         ///   <summary>
         ///  文件统一的编码格式
         ///   </summary>
         private  System.Text.Encoding _FileEncoding  =  System.Text.Encoding.UTF8;
         ///   <summary>
         ///  文件统一的编码格式
         ///   </summary>
         public  System.Text.Encoding FileEncoding
        {
             get  {  return  _FileEncoding; }
             set  { _FileEncoding  =  value; }
        }


         ///   <summary>
         ///  Cache文件存放基本目录
         ///   </summary>
         private   string  _FileSavePath  =   @" c:\CacheFiles\ " ;
         ///   <summary>
         ///  Cache文件存放基本目录
         ///   </summary>
         public   string  FileSavePath
        {
             get  {  return  _FileSavePath; }
             set  { _FileSavePath  =  value; }
        }

         ///   <summary>
         ///  文件扩展名
         ///   </summary>
         private   string  _FileExt  =   " .cache " ;
         ///   <summary>
         ///  Cache文件扩展名
         ///   </summary>
         public   string  FileExt
        {
             set  { _FileExt  =  value; }
             get  {  return  _FileExt; }
        }

         ///   <summary>
         ///  文件缓存的时间 单位分
         ///   </summary>
         private   int  _FileCacheMiniutes  =   2 ;
         ///   <summary>
         ///  文件缓存的时间 单位分
         ///   </summary>
         public   int  FileCacheMiniutes
        {
             get  {  return  _FileCacheMiniutes; }
             set  { _FileCacheMiniutes  =  value; }
        }
         #endregion

         ///   <summary>
         ///  检查文件是否存在
         ///   </summary>
         ///   <param name="p_FileName"> 文件名，不带路径，不带扩展名 </param>
         ///   <returns></returns>
         protected   bool  ExistFile( string  p_FileName)
        {
             bool  resultValue  =   false ;
             try
            {
                 string  strFileName  =  _FileSavePath  +  p_FileName  +  _FileExt;
                 if  (File.Exists(strFileName))
                {
                     // 文件是否过期
                    DateTime tmFile  =  File.GetLastWriteTime(strFileName);
                    DateTime tmNow  =  DateTime.Now;
                    TimeSpan ts  =  tmNow  -  tmFile;
                     if  (ts.TotalMinutes  <  _FileCacheMiniutes)
                    {
                        resultValue  =   true ;
                    }
                }

            }
             catch  (Exception ex)
          &nbs