Asp.net使用HttpHandler优化Css样式文件

        HttpHandler在Asp.net中核心对像之一,我们可以实现IHttpHandler接口来优化Css样式文件. 用一个我们自定义的HttpHandler映射.css的文件.
首先我们最小化Css样式文件尺寸, 然后我们再处理后CSS文件做内存缓存. 缓存依赖物理文件,当文件被修改后,重新加载. 这里我们以Demo为目的,默认
缓存时间2小时. 让我们先来看一下类图是这样的:

我们定义一个IFilesCache的接口,是为了实现两种不能缓存方式.一种是有用System.Web.Caching.Cache,别一个是用.net 4.0下System.Runtime.Caching.ObjectCache的内存Cache. 我们定义一个FilesCacheFactory的类根据.net framework当前版来在创建
当前的实例. 当然你可以直接选择其它组件实现缓存. 下面是Handler的代码:

    /// <summary>
    /// MinifyCssHandler
    /// </summary>
    public class MinifyCssHandler:IHttpHandler
    {
        private IFilesCache cacheContext;

        /// <summary>
        /// Initializes a new instance of the <see cref="MinifyCssHandler"/> class.
        /// </summary>
        public MinifyCssHandler()
        {
            cacheContext = FilesCacheFactory.GetInstance();
        }

        #region IHttpHandler Members

        /// <summary>
        /// Gets a value indicating whether another request can use the <see cref="T:System.Web.IHttpHandler"/> instance.
        /// </summary>
        /// <returns>true if the <see cref="T:System.Web.IHttpHandler"/> instance is reusable; otherwise, false.</returns>
        public bool IsReusable
        {
            get { return true; }
        }

        /// <summary>
        /// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler"/> interface.
        /// </summary>
        /// <param name="context">An <see cref="T:System.Web.HttpContext"/> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param>
        public void ProcessRequest(HttpContext context)
        {
            string fileContent = string.Empty;
            string filePath = context.Request.PhysicalPath;

            string cacheKey = string.Concat("css-", filePath);

            object cacheValue = cacheContext.GetFromCache(cacheKey);

            if (cacheValue == null)
            {
                fileContent = MinifyFiles(filePath);
                cacheContext.AddToCache(cacheKey, fileContent, filePath);
            }
            else
            {
                fileContent = cacheValue as string;
            }
            context.Response.ContentType = "text/css";
            context.Response.Write(fileContent);
        }

        #endregion

        /// <summary>
        /// MinifyFiles intent to minfiy css files size
        /// </summary>
        /// <param name="filePath">css file path</param>
        /// <returns>css file of content</returns>
        private string MinifyFiles(string filePath)
        {
            string fileContent = File.ReadAllText(filePath);
            fileContent = string.Concat("/* minifyed at ", DateTime.Now, " by Petter Liu */ ", fileContent);
            fileContent = Regex.Replace(fileContent, "\t", string.Empty);
            fileContent = Regex.Replace(fileContent, "\r\n", string.Empty);
            fileContent = Regex.Replace(fileContent, "\r", string.Empty);
            fileContent = Regex.Replace(fileContent, "\n", string.Empty);
            //Replace more than two spaces
            fileContent = Regex.Replace(fileContent, "[ ]{2,}", string.Empty);
            return fileContent;
        }
    }

与Cache相关的类:

 

    /// <summary>
    /// IFilesCache
    /// </summary>
    public interface IFilesCache
    {
        /// <summary>
        /// Add object to cache
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        /// <param name="filePath">file path</param>
        void AddToCache(string key, object value, string filePath);

        /// <summary>
        /// GetFromCache
        /// </summary>
        /// <param name="key">key</param>
        /// <returns>object</returns>
        object GetFromCache(string key);
    }

    /// <summary>
    /// a simple factory create IFilesCache
    /// </summary>
    public class FilesCacheFactory
    {
        /// <summary>
        /// Create IFilesCache instance
        /// </summary>
        /// <remarks>System.Runtime.Caching only runtime at .net framework version 4</remarks>
        /// <returns>IFilesCache</returns>
        public static IFilesCache GetInstance()
        {
            if (Environment.Version.Major==4)
               return new DotnetRunningCache();
            return new WebContextCache();
        }

    }

    public class WebContextCache:IFilesCache
    {
       #region IFilesCache Members
        /// <summary>
        /// Add object to cache
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        /// <param name="filePath">file path</param>
        public void  AddToCache(string key, object value, string filePath)
        {
            //Cache two hour
            HttpContext.Current.Cache.Insert(key, value,
                                          new CacheDependency(filePath),
                                          DateTime.Now.AddHours(2),
                                          TimeSpan.Zero);
        }

        /// <summary>
        /// GetFromCache
        /// </summary>
        /// <param name="key">key</param>
        /// <returns>object</returns>
        public object GetFromCache(string key)
        {
            if (string.IsNullOrEmpty(key))
                return new ArgumentNullException("cache key should not null");
            return HttpContext.Current.Cache[key];
        }

        #endregion
    }

    public class DotnetRunningCache:IFilesCache
    {
        #region IFilesCache Members
        /// <summary>
        /// Add object to cache
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">value</param>
        /// <param name="filePath">file path</param>
        public void AddToCache(string key, object value, string filePath)
        {
             ObjectCache cache = MemoryCache.Default;
            var cacheValue = new[] { value };
            var cachepolicy = new CacheItemPolicy();
            var filespath=new List<string>(){ filePath};
            cachepolicy.AbsoluteExpiration = DateTimeOffset.Now.AddHours(2);
            cachepolicy.ChangeMonitors.Add(new HostFileChangeMonitor(filespath));

            cache.Add(key, cacheValue, cachepolicy);
        }

        /// <summary>
        /// GetFromCache
        /// </summary>
        /// <param name="key">key</param>
        /// <returns>object</returns>
        public object GetFromCache(string key)
        {
            if (string.IsNullOrEmpty(key))
                return new ArgumentNullException("cache key should not null");

             ObjectCache cache = MemoryCache.Default;
            var objects= (Object[])cache.Get(key);
            if (objects != null)
                return objects.FirstOrDefault();
            return null;
        }

        #endregion
    }

在Web.config中增加:

        <httpHandlers>
            <add verb="*" path="*.css" validate="false" type="MyWeb.MinifyCssHandler"/>
        </httpHandlers>

Ok,对比一下,正常情况下是这样:

当增加这个优化Css的HttpHandler后, 是这样的:

有注意size从4.2KB变成了3.2KB. 以上我们直是实现比较简单的,你可以优化实现更高效的算法. 或增加扩展.

希望这篇Post对您开发有帮助.

作者：Petter Liu
出处：http://www.cnblogs.com/wintersun/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
该文章也同时发布在我的独立博客中-Petter Liu Blog。