Related Posts

string absFilePath = context.Request.PhysicalPath.Replace(".ashx", "");

if(!File.Exists(absFilePath))
{
    context.Response.StatusCode = 404;
    return;
}

public void ProcessRequest(HttpContext context)
{
    //Create full physical path( assuming "~" used)
    //build prefix
    string appRootPath = context.Request.PhysicalApplicationPath;
    //build suffix
    int startIndex = context.Request.PhysicalPath.IndexOf("~") + 2;
    int endIndex = context.Request.PhysicalPath.Length;
    string resourceAbsolutePath = context.Request.PhysicalPath.Substring(startIndex, endIndex - startIndex);

    string absFilePath = (appRootPath + resourceAbsolutePath);
    absFilePath = absFilePath.Replace(".ashx", "");
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Web;
using System.Web.Caching;
using System.IO;

namespace Ubu.Framework.Web
{

    public class FileResolver : IHttpHandler
    {

        #region Caching
        /// <summary>
        /// File cache item used to store file content & date entered into cache
        /// </summary>
        /// <example>
        /// HTML:
        /// <link rel="stylesheet" href="~/resources/ui/all.css.ashx" />
        /// web.config:
        /// <httpHandlers>
        /// <add verb="GET" path="*.css.ashx" type="Oxford.Web.FileResolver,Oxford.Web" />
        /// <add verb="GET" path="*.js.ashx" type="Oxford.Web.FileResolver,Oxford.Web" />
        /// </httpHandlers>
        /// </example>
        internal class FileCacheItemImage
        {
            internal byte[] Content;
            internal DateTime DateEntered = DateTime.Now;

            internal FileCacheItemImage(byte[] content)
            {
                this.Content = content;
            }

        }

        private FileCacheItemImage UpdateFileCacheImage(HttpContext context, byte[] content, string cacheKey)
        {

            FileCacheItemImage ci = new FileCacheItemImage(content);

            //Store the FileCacheItem in cache w/ a dependency on the file changing
            CacheDependency cd = new CacheDependency(cacheKey);
            context.Cache.Insert(cacheKey, ci, cd);
            return ci;
        }




        internal class FileCacheItemText
        {
            internal string Content;
            internal DateTime DateEntered = DateTime.Now;

            internal FileCacheItemText(string content)
            {
                this.Content = content;
            }


        }

        private FileCacheItemText UpdateFileCacheText(HttpContext context, string content, string cacheKey)
        {

            FileCacheItemText ci = new FileCacheItemText(content);

            //Store the FileCacheItem in cache w/ a dependency on the file changing
            CacheDependency cd = new CacheDependency(cacheKey);
            context.Cache.Insert(cacheKey, ci, cd);
            return ci;
        }

        public void ClearCache(HttpContext context)
        {
            List<string> keyList = new List<string>();
            System.Collections.IDictionaryEnumerator CacheEnum = context.Cache.GetEnumerator();
            while (CacheEnum.MoveNext())
            {
                keyList.Add(CacheEnum.Key.ToString());
            }
            foreach (string key in keyList)
            {
                context.Cache.Remove(key);
            }
        }

        #endregion

        public void ProcessRequest(HttpContext context)
        {


            /// Create full physical path( assuming "~" used always ) to normal path
            /// so we get grab the file.
            // build prefix
            string appRootPath = context.Request.PhysicalApplicationPath;
            // build suffix
            int startIndex = context.Request.PhysicalPath.IndexOf("~") + 2;
            int endIndex = context.Request.PhysicalPath.Length;
            string resourceAbsolutePath = context.Request.PhysicalPath.Substring(startIndex, endIndex - startIndex);


            string absFilePath = (appRootPath + resourceAbsolutePath);
            absFilePath = absFilePath.Replace(".ashx", "");

            if (!File.Exists(absFilePath))
            {
                context.Response.StatusCode = 404;
                return;
            }

            if (GetContentType(Path.GetExtension(absFilePath)).Contains("text") == false)
            {
                this.ProcessRequestedImage(context, absFilePath);
            }
            else
            {
                this.ProcessRequestedText(context,absFilePath);
            }


        }


        private void ProcessRequestedImage(HttpContext context, string absFilePath)
        {
            bool useCache = true;
            string cacheKey = absFilePath;
            Byte[] imageBytes = new byte[0];

            // Get data
            if (useCache)
            {
                // Check if the cache contains the image.
                Object cachedObject = context.Cache.Get(cacheKey);

                if (cachedObject != null)
                {
                    imageBytes = (Byte[])cachedObject;
                }
            }

            // check is not found in cache
            if (imageBytes.Length == 0)
            {
                imageBytes = this.PullDataAsBinary(context, absFilePath);

                if (useCache)
                {
                    // Store it in the cache (to be expired after 2 hours).
                    context.Cache.Add(cacheKey, imageBytes, null, DateTime.MaxValue, new TimeSpan(2, 0, 0), CacheItemPriority.Normal, null);
                }
            }

            // Send back in Response.
            context.Response.ContentType = "image/jpeg";
            context.Response.Cache.SetCacheability(HttpCacheability.Public);
            context.Response.Cache.SetLastModified(DateTime.Now);
            context.Response.BufferOutput = false;
            context.Response.OutputStream.Write(imageBytes, 0, imageBytes.Length);
            //context.Response.End;
        }

        private void ProcessRequestedText(HttpContext context, string absFilePath)
        {
            bool useCache = false;
            string cacheKey = absFilePath;
            string content = string.Empty;

            // Get data
            if (useCache)
            {
                // Check if the cache contains the image.
                Object cachedObject = context.Cache.Get(cacheKey);

                if (cachedObject != null)
                {
                    content = (string)cachedObject;
                }
            }

            // check is not found in cache
            if (content.Length == 0)
            {
                content = this.PullDataAsText(context, absFilePath);
                content = this.ParseData(content);  // to ensure .ashx paths are converted also

                if (useCache)
                {
                    // Store it in the cache (to be expired after 2 hours).
                    context.Cache.Add(cacheKey, content, null, DateTime.MaxValue, new TimeSpan(2, 0, 0), CacheItemPriority.Normal, null);
                }
            }

            context.Response.Cache.SetLastModified(DateTime.Now);
            context.Response.ContentType = GetContentType(Path.GetExtension(absFilePath));
            context.Response.Write(content);
            context.Response.End();
        }

        private string ParseData(string contentString)
        {

            /// Make internal paths legal.
            //Get absolute application path
            string relAppPath = HttpRuntime.AppDomainAppVirtualPath;
            if (!relAppPath.EndsWith("/"))
                relAppPath += "/";

            //Replace virtual paths w/ absolute path
            contentString = contentString.Replace("~/", relAppPath);

            // replace ".ashx" with nothing
            contentString = contentString.Replace(".ashx", "");


            return contentString;
        }

        private byte[] ParseData(byte[] contentBytes)
        {
            byte[] resultBytes;
            string contentString;

            // convert to String
            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
            contentString = enc.GetString(contentBytes);

            contentString = this.ParseData(contentString);

            // convert back to Bytes
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
            resultBytes = encoding.GetBytes(contentString);

            return resultBytes;
        }

        private string PullDataAsText(HttpContext context, string filePath)
        {
            string data;

            using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                using (StreamReader sr = new StreamReader(fs))
                {
                    data = sr.ReadToEnd();
                }
            }

            return data;
        }

        private Byte[] PullDataAsBinary(HttpContext context, string filePath)
        {
            byte[] data;

            using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                data = new byte[fs.Length];
                fs.Read(data, 0, data.Length);
                fs.Close();
            }

            return data;
        }



        /// <summary>
        /// Gets the appropriate content type for a specified extension
        /// </summary>
        private string GetContentType(string ext)
        {
            switch (ext.ToLower())
            {
                case ".css":
                    return "text/css";
                case ".xml":
                    return "text/xml";
                case ".js":
                    return "text/javascript";
                case ".png":
                    return "image/png";
                default:
                    throw new NotSupportedException("The File extension of [" + ext + "] is not supported.");
            }
        }

        #region IHttpHandler Members

        public bool IsReusable
        {
            get
            {
                return true;
            }
        }

        #endregion
    }
}

...


            if (absFilePath.Contains("\\~\\"))
            {
                absFilePath = absFilePath.Replace("\\~\\", "\\");
            }



..