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)
                {