public IVirtualFile GetFileIfCached(string virtualPath, System.Collections.Specialized.NameValueCollection queryString, IVirtualFile original) { //Use alternate cache key if provided string key = original is IVirtualFileSourceCacheKey ? ((IVirtualFileSourceCacheKey)original).GetCacheKey(true) : original.VirtualPath; //If cached, serve it. CachedVirtualFile c = cache.Get(key); if (c != null) { return(c); } //If not, let's cache it. if ("mem".Equals(queryString["scache"], StringComparison.OrdinalIgnoreCase)) { locks.TryExecute(key, 3000, delegate() { c = cache.Get(key); if (c == null) { using (Stream data = original.Open()) {//Very long-running call c = new CachedVirtualFile(original.VirtualPath, StreamExtensions.CopyToBytes(data, true)); } cache.Set(key, c);//Save to cache (may trigger cleanup) } }); return(c); } return(null); }
public bool WriteToStream( BaseCompositeFileProcessingProvider provider, StreamWriter sw, IVirtualFile vf, ClientDependencyType type, string origUrl, HttpContextBase http) { try { using (var readStream = vf.Open()) using (var streamReader = new StreamReader(readStream)) { var output = streamReader.ReadToEnd(); DefaultFileWriter.WriteContentToStream(provider, sw, output, type, http, origUrl); return(true); } } catch (Exception exception) { LogHelper.Warn(typeof(EmbeddedResourceVirtualFileWriter), exception.Message); return(false); } }
/// <inheritdoc/> public bool WriteToStream( BaseCompositeFileProcessingProvider provider, StreamWriter streamWriter, IVirtualFile virtualFile, ClientDependencyType type, string originalUrl, HttpContextBase context) { StreamReader streamReader = null; try { Stream readStream = virtualFile.Open(); streamReader = new StreamReader(readStream); string output = streamReader.ReadToEnd(); DefaultFileWriter.WriteContentToStream(provider, streamWriter, output, type, context, originalUrl); return(true); } catch (Exception) { // The file must have failed to open return(false); } finally { // readStream is disposed by the streamReader. streamReader?.Dispose(); } }
MemCachedFile( IVirtualFile file ) { if (file == null) throw new FileNotFoundException(); this.path = file.VirtualPath; using (Stream s = file.Open()) { this.data = StreamExtensions.CopyToBytes(s); } }
MemCachedFile(IVirtualFile file) { if (file == null) { throw new FileNotFoundException(); } this.path = file.VirtualPath; using (Stream s = file.Open()) { this.data = StreamExtensions.CopyToBytes(s); } }
/// <summary> /// The write to stream. /// </summary> /// <param name="provider"> /// The provider. /// </param> /// <param name="sw"> /// The sw. /// </param> /// <param name="vf"> /// The vf. /// </param> /// <param name="type"> /// The type. /// </param> /// <param name="origUrl"> /// The orig url. /// </param> /// <param name="http"> /// The http. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public bool WriteToStream(BaseCompositeFileProcessingProvider provider, StreamWriter sw, IVirtualFile vf, ClientDependencyType type, string origUrl, HttpContextBase http) { try { using (var readStream = vf.Open()) using (var streamReader = new StreamReader(readStream)) { var output = streamReader.ReadToEnd(); DefaultFileWriter.WriteContentToStream(provider, sw, output, type, http, origUrl); return true; } } catch (Exception) { // the file must have failed to open return false; } }
public bool WriteToStream(BaseCompositeFileProcessingProvider provider, StreamWriter sw, IVirtualFile vf, ClientDependencyType type, string origUrl, HttpContextBase http) { try { using (var readStream = vf.Open()) using (var streamReader = new StreamReader(readStream)) { var output = streamReader.ReadToEnd(); DefaultFileWriter.WriteContentToStream(provider, sw, output, type, http, origUrl); return(true); } } catch (Exception) { // the file must have failed to open return(false); } }
public IVirtualFile GetFileIfCached(string virtualPath, System.Collections.Specialized.NameValueCollection queryString, IVirtualFile original) { if (!"disk".Equals(queryString["scache"], StringComparison.OrdinalIgnoreCase)) { return(null); } if (this.AsyncModuleMode) { throw new InvalidOperationException("SourceDiskCache cannot be used in synchronous mode if AsyncModuleMode=true"); } //Verify web.config exists in the cache folder. writer.CheckWebConfigEvery5(); //Use alternate cache key if provided string key = original is IVirtualFileSourceCacheKey ? ((IVirtualFileSourceCacheKey)original).GetCacheKey(false) : original.VirtualPath; //If cached, serve it. var r = cache.GetCachedFile(key, ".cache", delegate(Stream target) { using (Stream data = original.Open()) { //Very long-running call data.CopyToStream(target); } }, 15 * 1000, true); if (r.Result == CacheQueryResult.Failed) { return(null); } if (r.Result == CacheQueryResult.Hit && cleaner != null) { cleaner.UsedFile(r.RelativePath, r.PhysicalPath); } return(new SourceVirtualFile(original.VirtualPath, delegate(){ return r.Data ?? File.Open(r.PhysicalPath, FileMode.Open, FileAccess.Read, FileShare.Read); })); }
public IVirtualFile GetFileIfCached(string virtualPath, System.Collections.Specialized.NameValueCollection queryString, IVirtualFile original) { if (!"disk".Equals(queryString["scache"], StringComparison.OrdinalIgnoreCase)) { return(null); } //Verify web.config exists in the cache folder. writer.CheckWebConfigEvery5(); //Use alternate cache key if provided string key = original is IVirtualFileSourceCacheKey ? ((IVirtualFileSourceCacheKey)original).GetCacheKey(false) : original.VirtualPath; //If cached, serve it. var r = cache.GetCachedFile(key, ".cache", delegate(Stream target) { using (Stream data = original.Open()) {//Very long-running call StreamExtensions.CopyToStream(data, target); } }, DateTime.MinValue, 15 * 1000, true); if (r.Result == CacheQueryResult.Failed) { throw new ImageResizer.ImageProcessingException("Failed to acquire a lock on file \"" + r.PhysicalPath + "\" within 15 seconds. Source caching failed."); } if (r.Result == CacheQueryResult.Hit && cleaner != null) { cleaner.UsedFile(r.RelativePath, r.PhysicalPath); } return(new SourceVirtualFile(original.VirtualPath, delegate(){ return r.Data ?? File.Open(r.PhysicalPath, FileMode.Open, FileAccess.Read, FileShare.Read); })); }
/// <summary> /// Writes the virtual file to a stream for serving. /// </summary> /// <param name="provider">The file processing provider.</param> /// <param name="streamWriter">The <see cref="StreamWriter"/>.</param> /// <param name="virtualFile">The <see cref="IVirtualFile"/> to write.</param> /// <param name="type">The <see cref="ClientDependencyType"/> the virtual file matches.</param> /// <param name="originalUrl">The original url to the virtual file.</param> /// <param name="context">The <see cref="HttpContextBase"/>.</param> /// <returns> /// The <see cref="bool"/>. /// </returns> public bool WriteToStream( BaseCompositeFileProcessingProvider provider, StreamWriter streamWriter, IVirtualFile virtualFile, ClientDependencyType type, string originalUrl, HttpContextBase context) { try { using (Stream readStream = virtualFile.Open()) using (StreamReader streamReader = new StreamReader(readStream)) { string output = streamReader.ReadToEnd(); DefaultFileWriter.WriteContentToStream(provider, streamWriter, output, type, context, originalUrl); return true; } } catch (Exception) { // The file must have failed to open return false; } }
public IVirtualFile GetFileIfCached(string virtualPath, System.Collections.Specialized.NameValueCollection queryString, IVirtualFile original) { //Use alternate cache key if provided string key = original is IVirtualFileSourceCacheKey ? ((IVirtualFileSourceCacheKey)original).GetCacheKey(true) : original.VirtualPath; //If cached, serve it. CachedVirtualFile c = cache.Get(key); if (c != null) return c; //If not, let's cache it. if ("mem".Equals(queryString["scache"], StringComparison.OrdinalIgnoreCase)) { locks.TryExecute(key, 3000, delegate() { c = cache.Get(key); if (c == null) { using (Stream data = original.Open()) {//Very long-running call c = new CachedVirtualFile(original.VirtualPath, StreamExtensions.CopyToBytes(data, true)); } cache.Set(key, c);//Save to cache (may trigger cleanup) } }); return c; } return null; }
/// <summary> /// Generates the resized image to disk (if needed), then rewrites the request to that location. /// Perform 404 checking before calling this method. Assumes file exists. /// Called during PostAuthorizeRequest /// </summary> /// <param name="context"></param> /// <param name="ra"></param> /// <param name="vf"></param> protected virtual void HandleRequest(HttpContext context, HttpModuleRequestAssistant ra, IVirtualFile vf) { if (!ra.CachingIndicated && !ra.ProcessingIndicated) { ra.ApplyRewrittenPath(); //This is needed for both physical and virtual files; only makes changes if needed. if (vf != null) { ra.AssignSFH(); //Virtual files are not served in .NET 4. } return; } context.Items[conf.ResponseArgsKey] = ""; //We are handling the request //Communicate to the MVC plugin this request should not be affected by the UrlRoutingModule. context.Items[conf.StopRoutingKey] = true; ra.EstimateResponseInfo(); //Build CacheEventArgs ResponseArgs e = new ResponseArgs(); //Add the modified date to the request key, if present. var modDate = (vf == null) ? System.IO.File.GetLastWriteTimeUtc(ra.RewrittenMappedPath) : (vf is IVirtualFileWithModifiedDate ? ((IVirtualFileWithModifiedDate)vf).ModifiedDateUTC : DateTime.MinValue); e.RequestKey = ra.GenerateRequestCachingKey(modDate); var settings = new ResizeSettings(ra.RewrittenInstructions); e.RewrittenQuerystring = settings; e.ResponseHeaders.ContentType = ra.EstimatedContentType; e.SuggestedExtension = ra.EstimatedFileExtension; //A delegate for accessing the source file e.GetSourceImage = new GetSourceImageDelegate(delegate() { return((vf != null) ? vf.Open() : File.Open(ra.RewrittenMappedPath, FileMode.Open, FileAccess.Read, FileShare.Read)); }); //Add delegate for writing the data stream e.ResizeImageToStream = new ResizeImageDelegate(delegate(System.IO.Stream stream) { //This runs on a cache miss or cache invalid. This delegate is preventing from running in more //than one thread at a time for the specified cache key try { if (!ra.ProcessingIndicated) { //Just duplicate the data using (Stream source = e.GetSourceImage()) source.CopyToStream(stream); //4KiB buffer } else { ImageJob j; //Process the image if (vf != null) { j = new ImageJob(vf, stream, settings); } else { j = new ImageJob(ra.RewrittenMappedPath, stream, settings); //Use a physical path to bypass virtual file system } conf.GetImageBuilder().Build(j); } ra.FireJobSuccess(); //Catch not found exceptions } catch (System.IO.FileNotFoundException notFound) { if (notFound.Message.Contains(" assembly ")) { throw; //If an assembly is missing, it should be a 500, not a 404 } //This will be called later, if at all. ra.FireMissing(); throw new ImageMissingException("The specified resource could not be located", "File not found", notFound); } catch (System.IO.DirectoryNotFoundException notFound) { ra.FireMissing(); throw new ImageMissingException("The specified resource could not be located", "File not found", notFound); } catch (Exception ex) { ra.FireJobException(ex); throw; } }); context.Items[conf.ResponseArgsKey] = e; //store in context items //Fire events (for client-side caching plugins) conf.FirePreHandleImage(this, context, e); //Pass the rest of the work off to the caching module. It will handle rewriting/redirecting and everything. //We handle request headers based on what is found in context.Items ICache cache = conf.GetCacheProvider().GetCachingSystem(context, e); //Verify we have a caching system if (cache == null) { throw new ImageProcessingException("Image Resizer: No caching plugin was found for the request"); } cache.Process(context, e); //TODO: Verify that caching systems serves request or transfers to StaticFileHandler }
/// <summary> /// Generates the resized image to disk (if needed), then rewrites the request to that location. /// Perform 404 checking before calling this method. Assumes file exists. /// Called during PostAuthorizeRequest /// </summary> /// <param name="context"></param> /// <param name="virtualPath"></param> /// <param name="queryString"></param> /// <param name="vf"></param> protected virtual void HandleRequest(HttpContext context, string virtualPath, NameValueCollection queryString, IVirtualFile vf) { Stopwatch s = new Stopwatch(); s.Start(); ResizeSettings settings = new ResizeSettings(queryString); bool isCaching = settings.Cache == ServerCacheMode.Always; bool isProcessing = settings.Process == ProcessWhen.Always; //By default, we process it if is both (a) a recognized image extension, and (b) has a resizing directive (not just 'cache'). if (settings.Process == ProcessWhen.Default) { //Check for resize directive by removing ('non-resizing' items from the current querystring) NameValueCollection copy = new NameValueCollection(queryString); copy.Remove("cache"); copy.Remove("process"); copy.Remove("useresizingpipeline"); copy.Remove("404"); copy.Remove("404.filterMode"); copy.Remove("404.except"); //If the 'copy' still has directives, and it's an image request, then let's process it. isProcessing = conf.IsAcceptedImageType(virtualPath) && conf.HasPipelineDirective(copy); } //By default, we only cache it if we're processing it. if (settings.Cache == ServerCacheMode.Default && isProcessing) { isCaching = true; } //Resolve the 'cache' setting to 'no' unless we want it cache. if (!isCaching) { settings.Cache = ServerCacheMode.No; } //If we are neither processing nor caching, don't do anything more with the request if (!isProcessing && !isCaching) { return; } context.Items[conf.ResponseArgsKey] = ""; //We are handling the requests //Communicate to the MVC plugin this request should not be affected by the UrlRoutingModule. context.Items[conf.StopRoutingKey] = true; //Find out if we have a modified date that we can work with bool hasModifiedDate = (vf == null) || vf is IVirtualFileWithModifiedDate; DateTime modDate = DateTime.MinValue; if (hasModifiedDate && vf != null) { modDate = ((IVirtualFileWithModifiedDate)vf).ModifiedDateUTC; if (modDate == DateTime.MinValue || modDate == DateTime.MaxValue) { hasModifiedDate = false; //Skip modified date checking if the file has no modified date } } IEncoder guessedEncoder = null; //Only use an encoder to determine extension/mime-type when it's an image extension or when we've set process = always. if (isProcessing) { guessedEncoder = conf.GetImageBuilder().EncoderProvider.GetEncoder(settings, virtualPath); if (guessedEncoder == null) { throw new ImageProcessingException("Image Resizer: No image encoder was found for the request."); } } //Determine the file extenson for the caching system to use if we aren't processing the image //Use the exsiting one if is an image extension. If not, use "unknown". // We don't want to suggest writing .exe or .aspx files to the cache! string fallbackExtension = PathUtils.GetFullExtension(virtualPath).TrimStart('.'); if (!conf.IsAcceptedImageType(virtualPath)) { fallbackExtension = "unknown"; } //Determine the mime-type if we aren't processing the image. string fallbackContentType = "application/octet-stream"; //Support jpeg, png, gif, bmp, tiff mime-types. Otherwise use "application/octet-stream". //We can't set it to null - it will default to text/html System.Drawing.Imaging.ImageFormat recognizedExtension = DefaultEncoder.GetImageFormatFromExtension(fallbackExtension); if (recognizedExtension != null) { fallbackContentType = DefaultEncoder.GetContentTypeFromImageFormat(recognizedExtension); } //Build CacheEventArgs ResponseArgs e = new ResponseArgs(); e.RequestKey = virtualPath + PathUtils.BuildQueryString(queryString); e.RewrittenQuerystring = settings; e.ResponseHeaders.ContentType = isProcessing ? guessedEncoder.MimeType : fallbackContentType; e.SuggestedExtension = isProcessing ? guessedEncoder.Extension : fallbackExtension; e.HasModifiedDate = hasModifiedDate; //Add delegate for retrieving the modified date of the source file. e.GetModifiedDateUTC = new ModifiedDateDelegate(delegate() { if (vf == null) { return(System.IO.File.GetLastWriteTimeUtc(HostingEnvironment.MapPath(virtualPath))); } else if (hasModifiedDate) { return(modDate); } else { return(DateTime.MinValue); //Won't be called, no modified date available. } }); //A delegate for accessing the source file e.GetSourceImage = new GetSourceImageDelegate(delegate() { return((vf != null) ? vf.Open() : File.Open(HostingEnvironment.MapPath(virtualPath), FileMode.Open, FileAccess.Read, FileShare.Read)); }); //Add delegate for writing the data stream e.ResizeImageToStream = new ResizeImageDelegate(delegate(System.IO.Stream stream) { //This runs on a cache miss or cache invalid. This delegate is preventing from running in more //than one thread at a time for the specified cache key try { if (!isProcessing) { //Just duplicate the data using (Stream source = e.GetSourceImage()) StreamExtensions.CopyToStream(source, stream); //4KiB buffer } else { //Process the image if (vf != null) { conf.GetImageBuilder().Build(vf, stream, settings); } else { conf.GetImageBuilder().Build(HostingEnvironment.MapPath(virtualPath), stream, settings); //Use a physical path to bypass virtual file system } } //Catch not found exceptions } catch (System.IO.FileNotFoundException notFound) { //This will be called later, if at all. FileMissing(context, virtualPath, queryString); throw new ImageMissingException("The specified resource could not be located", "File not found", notFound); } catch (System.IO.DirectoryNotFoundException notFound) { FileMissing(context, virtualPath, queryString); throw new ImageMissingException("The specified resource could not be located", "File not found", notFound); } }); context.Items[conf.ResponseArgsKey] = e; //store in context items //Fire events (for client-side caching plugins) conf.FirePreHandleImage(this, context, e); //Pass the rest of the work off to the caching module. It will handle rewriting/redirecting and everything. //We handle request headers based on what is found in context.Items ICache cache = conf.GetCacheProvider().GetCachingSystem(context, e); //Verify we have a caching system if (cache == null) { throw new ImageProcessingException("Image Resizer: No caching plugin was found for the request"); } cache.Process(context, e); s.Stop(); context.Items["ResizingTime"] = s.ElapsedMilliseconds; }
public IVirtualFile GetFileIfCached(string virtualPath, System.Collections.Specialized.NameValueCollection queryString, IVirtualFile original) { if (!"disk".Equals(queryString["scache"], StringComparison.OrdinalIgnoreCase)) return null; //Verify web.config exists in the cache folder. writer.CheckWebConfigEvery5(); //Use alternate cache key if provided string key = original is IVirtualFileSourceCacheKey ? ((IVirtualFileSourceCacheKey)original).GetCacheKey(false) : original.VirtualPath; //If cached, serve it. var r = cache.GetCachedFile(key, ".cache", delegate(Stream target) { using (Stream data = original.Open()) {//Very long-running call StreamExtensions.CopyToStream(data, target); } }, DateTime.MinValue, 15 * 1000,true); if (r.Result == CacheQueryResult.Failed) throw new ImageResizer.ImageProcessingException("Failed to acquire a lock on file \"" + r.PhysicalPath + "\" within 15 seconds. Source caching failed."); if (r.Result == CacheQueryResult.Hit && cleaner != null) cleaner.UsedFile(r.RelativePath, r.PhysicalPath); return new SourceVirtualFile(original.VirtualPath,delegate(){ return r.Data ?? File.Open(r.PhysicalPath, FileMode.Open, FileAccess.Read, FileShare.Read); }); }
public override System.IO.Stream Open() { return(f.Open()); }
/// <summary> /// Generates the resized image to disk (if needed), then rewrites the request to that location. /// Perform 404 checking before calling this method. Assumes file exists. /// Called during PostAuthorizeRequest /// </summary> /// <param name="context"></param> /// <param name="virtualPath"></param> /// <param name="queryString"></param> /// <param name="vf"></param> protected virtual void HandleRequest(HttpContext context, string virtualPath, NameValueCollection queryString, IVirtualFile vf) { Stopwatch s = new Stopwatch(); s.Start(); ResizeSettings settings = new ResizeSettings(queryString); bool isCaching = settings.Cache == ServerCacheMode.Always; bool isProcessing = settings.Process == ProcessWhen.Always; //By default, we process it if is both (a) a recognized image extension, and (b) has a resizing directive (not just 'cache'). if (settings.Process == ProcessWhen.Default){ //Check for resize directive by removing ('non-resizing' items from the current querystring) NameValueCollection copy = new NameValueCollection(queryString); copy.Remove("cache"); copy.Remove("process"); copy.Remove("useresizingpipeline"); copy.Remove("404"); copy.Remove("404.filterMode"); copy.Remove("404.except"); //If the 'copy' still has directives, and it's an image request, then let's process it. isProcessing = conf.IsAcceptedImageType(virtualPath) && conf.HasPipelineDirective(copy); } //By default, we only cache it if we're processing it. if (settings.Cache == ServerCacheMode.Default && isProcessing) isCaching = true; //Resolve the 'cache' setting to 'no' unless we want it cache. if (!isCaching) settings.Cache = ServerCacheMode.No; //If we are neither processing nor caching, don't do anything more with the request if (!isProcessing && !isCaching) return; context.Items[conf.ResponseArgsKey] = ""; //We are handling the requests //Communicate to the MVC plugin this request should not be affected by the UrlRoutingModule. context.Items[conf.StopRoutingKey] = true; //Find out if we have a modified date that we can work with bool hasModifiedDate = (vf == null) || vf is IVirtualFileWithModifiedDate; DateTime modDate = DateTime.MinValue; if (hasModifiedDate && vf != null) { modDate = ((IVirtualFileWithModifiedDate)vf).ModifiedDateUTC; if (modDate == DateTime.MinValue || modDate == DateTime.MaxValue) { hasModifiedDate = false; //Skip modified date checking if the file has no modified date } } IEncoder guessedEncoder = null; //Only use an encoder to determine extension/mime-type when it's an image extension or when we've set process = always. if (isProcessing) { guessedEncoder = conf.GetImageBuilder().EncoderProvider.GetEncoder(settings, virtualPath); if (guessedEncoder == null) throw new ImageProcessingException("Image Resizer: No image encoder was found for the request."); } //Determine the file extenson for the caching system to use if we aren't processing the image //Use the exsiting one if is an image extension. If not, use "unknown". // We don't want to suggest writing .exe or .aspx files to the cache! string fallbackExtension = PathUtils.GetFullExtension(virtualPath).TrimStart('.'); if (!conf.IsAcceptedImageType(virtualPath)) fallbackExtension = "unknown"; //Determine the mime-type if we aren't processing the image. string fallbackContentType = "application/octet-stream"; //Support jpeg, png, gif, bmp, tiff mime-types. Otherwise use "application/octet-stream". //We can't set it to null - it will default to text/html System.Drawing.Imaging.ImageFormat recognizedExtension = DefaultEncoder.GetImageFormatFromExtension(fallbackExtension); if (recognizedExtension != null) fallbackContentType = DefaultEncoder.GetContentTypeFromImageFormat(recognizedExtension); //Build CacheEventArgs ResponseArgs e = new ResponseArgs(); e.RequestKey = virtualPath + PathUtils.BuildQueryString(queryString); e.RewrittenQuerystring = settings; e.ResponseHeaders.ContentType = isProcessing ? guessedEncoder.MimeType : fallbackContentType; e.SuggestedExtension = isProcessing ? guessedEncoder.Extension : fallbackExtension; e.HasModifiedDate = hasModifiedDate; //Add delegate for retrieving the modified date of the source file. e.GetModifiedDateUTC = new ModifiedDateDelegate(delegate() { if (vf == null) return System.IO.File.GetLastWriteTimeUtc(HostingEnvironment.MapPath(virtualPath)); else if (hasModifiedDate) return modDate; else return DateTime.MinValue; //Won't be called, no modified date available. }); //A delegate for accessing the source file e.GetSourceImage = new GetSourceImageDelegate(delegate() { return (vf != null) ? vf.Open() : File.Open(HostingEnvironment.MapPath(virtualPath), FileMode.Open, FileAccess.Read, FileShare.Read); }); //Add delegate for writing the data stream e.ResizeImageToStream = new ResizeImageDelegate(delegate(System.IO.Stream stream) { //This runs on a cache miss or cache invalid. This delegate is preventing from running in more //than one thread at a time for the specified cache key try { if (!isProcessing) { //Just duplicate the data using (Stream source = e.GetSourceImage()) StreamExtensions.CopyToStream(source, stream); //4KiB buffer } else { //Process the image if (vf != null) conf.GetImageBuilder().Build(vf, stream, settings); else conf.GetImageBuilder().Build(HostingEnvironment.MapPath(virtualPath), stream, settings); //Use a physical path to bypass virtual file system } //Catch not found exceptions } catch (System.IO.FileNotFoundException notFound) { //This will be called later, if at all. FileMissing(context, virtualPath, queryString); throw new ImageMissingException("The specified resource could not be located","File not found", notFound); } catch (System.IO.DirectoryNotFoundException notFound) { FileMissing(context, virtualPath, queryString); throw new ImageMissingException("The specified resource could not be located", "File not found", notFound); } }); context.Items[conf.ResponseArgsKey] = e; //store in context items //Fire events (for client-side caching plugins) conf.FirePreHandleImage(this, context, e); //Pass the rest of the work off to the caching module. It will handle rewriting/redirecting and everything. //We handle request headers based on what is found in context.Items ICache cache = conf.GetCacheProvider().GetCachingSystem(context, e); //Verify we have a caching system if (cache == null) throw new ImageProcessingException("Image Resizer: No caching plugin was found for the request"); cache.Process(context, e); s.Stop(); context.Items["ResizingTime"] = s.ElapsedMilliseconds; }