ASP.NET 打包多CSS或JS文件以加快页面加载速度的Handler

ASP.NET 打包多CSS或JS文件以加快页面加载速度的Handler，

使用<link type="text/css" rel="Stylesheet" href="HttpCombiner.ashx?" />，具体的参数请参考程序中的介绍。附件

using System;

using System.IO;

using System.IO.Compression;

using System.Net;

using System.Text;

using System.Web;

using System.Web.Services;

namespace SLTech.DST.Web.Application

{

    /// <summary>

    /// Summary description for $codebehindclassname$

    /// </summary>

    [WebService(Namespace = "http://tempuri.org/")]

    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

    public class HttpCombiner : IHttpHandler

    {

        private const bool DO_GZIP = true;

        private readonly static TimeSpan CACHE_DURATION = TimeSpan.FromDays(30);

        private const string DEFAULT_CSS = "decision-support-toolkit.css,controls/tab.css,controls/extension-button.css,";

        public void ProcessRequest(HttpContext context)

        {

            var request = context.Request;

            // Read setName, contentType and version.

            //All are required. They are used as cache key

            var setName = request["s"] ?? string.Empty;

            var contentType = request["t"] ?? string.Empty;

            var version = request["v"] ?? string.Empty;

            var files = request["f"] ?? string.Empty;

            files = DEFAULT_CSS + files;

            // Decide if browser supports compressed response

            var isCompressed = DO_GZIP && this.CanGZip(context.Request);

            // Response is written as UTF8 encoding.

            var encoding = new UTF8Encoding(false);

            // If the set has already been cached, write the response directly from

            // cache. Otherwise generate the response and cache it

            if (!this.WriteFromCache(context, setName, version, isCompressed, contentType))

            {

                using (var memoryStream = new MemoryStream(5000))

                {

                    // Decide regular stream or GZipStream based on whether the response

                    // can be cached or not

                    using (var writer = isCompressed ?

                        (Stream)(new GZipStream(memoryStream, CompressionMode.Compress)) :

                        memoryStream)

                    {

                        // Load the files defined and process each file

                        var fileNames = files.Split(new char[] { ',' },

                            StringSplitOptions.RemoveEmptyEntries);

                        foreach (string fileName in fileNames)

                        {

                            var fileBytes = this.GetFileBytes(context,"css/"+fileName.Trim(), encoding);

                            writer.Write(fileBytes, 0, fileBytes.Length);

                        }

                        writer.Close();

                    }

                    var responseBytes = memoryStream.ToArray();

                    context.Cache.Insert(GetCacheKey(setName, version, isCompressed),

                        responseBytes, null, System.Web.Caching.Cache.NoAbsoluteExpiration,

                        CACHE_DURATION);

                    // Generate the response

                    this.WriteBytes(responseBytes, context, isCompressed, contentType);

                }

            }

        }

        private byte[] GetFileBytes(HttpContext context, string virtualPath, Encoding encoding)

        {

            if (virtualPath.StartsWith("http://", StringComparison.InvariantCultureIgnoreCase))

            {

                using (var client = new WebClient())

                {

                    return client.DownloadData(virtualPath);

                }

            }

            else

            {

                var physicalPath = context.Server.MapPath(virtualPath);

                var bytes = File.ReadAllBytes(physicalPath);

                return bytes;

            }

        }

        private bool WriteFromCache(HttpContext context, string setName, string version,

            bool isCompressed, string contentType)

        {

            var responseBytes = context.Cache[GetCacheKey(setName, version, isCompressed)] as byte[];

            if (null == responseBytes || 0 == responseBytes.Length) return false;

            this.WriteBytes(responseBytes, context, isCompressed, contentType);

            return true;

        }

        private void WriteBytes(byte[] bytes, HttpContext context,

            bool isCompressed, string contentType)

        {

            var response = context.Response;

            response.AppendHeader("Content-Length", bytes.Length.ToString());

            response.ContentType = contentType;

            if (isCompressed)

                response.AppendHeader("Content-Encoding", "gzip");

            context.Response.Cache.SetCacheability(HttpCacheability.Public);

            context.Response.Cache.SetExpires(DateTime.Now.Add(CACHE_DURATION));

            context.Response.Cache.SetMaxAge(CACHE_DURATION);

            context.Response.Cache.AppendCacheExtension("must-revalidate, proxy-revalidate");

            response.OutputStream.Write(bytes, 0, bytes.Length);

            response.Flush();

        }

        private bool CanGZip(HttpRequest request)

        {

            var acceptEncoding = request.Headers["Accept-Encoding"];

            return (!string.IsNullOrEmpty(acceptEncoding) &&

                    (acceptEncoding.Contains("gzip") || acceptEncoding.Contains("deflate")));

        }

        private string GetCacheKey(string setName, string version, bool isCompressed)

        {

            return "HttpCombiner." + setName + "." + version + "." + isCompressed;

        }

        public bool IsReusable

        {

            get

            {

                return false;

            }

        }

    }

}