Fixed

• I finally tracked down a simple, yet elusive performance bug  that was particularly problematic for users with many thousands of images. Performance should be much better for everyone now, so upgrading is highly suggested.  This bug was introduced with version 2.0., and caused a filesystem listing hit for each request.
• All requests are now forced to pass through the UrlAuthorizationModule now. Previously, any URL rewriting (like customfolders.cs) caused URL auth rules to be circumvented. This was documented behavior, but a secure solution has now been found.

Added

• New users will find it much easier to get things working – Messing with IIS is now completely optional!
  Instead of writing  “image.jpg?width=500″ as you normally would, type “image.jpg.axd?width=500″. If you use the new syntax, you won’t be forced to configure wildcard mapping on IIS6/IIS7 classic.
  Both syntaxes will be supported in the future.
  The suggested extension is .axd, but that can be changed or disabled using the ResizeExtension application setting.
  
• Dithering support added! You can dither an 8-bit image using the ?dither= command. You can specify a dither percent, “true”, or “4pass”.
• UploadSample  project (in VB). Resizing images as they are uploaded is now trivally easy. ImageManager.BuildImage now accepts an HttpPostedFile instance for resizing.
• DisableCustomQuantization setting to allow GIFs to be generated on servers where the Marshal class is prohibited.
• PerfTests project to run benchmarks on the image resizing and encoding code.

Upgrade proccess

1. Replace the old files with the new files from the ImageResizer folder. If you are using the .DLL, replace the DLL in the bin folder. Keep your old CustomFolders.cs and WatermarkSettings.cs files if you have modified them.
2. Delete the /imagecache directory.
3. Insert/change the following application settings in web.config if you want to use the new syntax.

<add key="ResizeExtension" value=".axd"/>

<add key="AllowURLRewriting" value="true"/>

If you are upgrading from 1.2, follow the 1.2->2.0 upgrade instructions first.

Read 20 Image Resizing Pitfalls first (part 1). It explains why you need an HttpModule instead of an HttpHandler, why disk caching is a requirement, and why you always want to let IIS serve static files.

This article gives an architectural overview of my image resizer. The design has evolved several times as my needs grew, but I think the design has now matured to be very simple, modular, and extensible.

Request flow

1. Only intercept image requests that include certain querystring commands. Leave other requests intact.
2. Check to see if the resized image for the request URL is already cached. If cached and still up-to-date with the source file, goto step 4.
3. If not already cached, process the image and cache it.
4. Rewrite the request (not redirect) to the cached file. This will allow IIS to serve the file with full HTTP support (range requests, caching, not-modified support, etc).

A few other goals

1. Allow custom syntaxes like /resize(50,50)/image.jpg or ?theme=smallthumb to be easily added without bloating the core module.
2. Permit or disable filename rewriting from Web.config. /resize(50,50)/ would be path rewriting, wheras ?theme=smallthumb would be just rewriting the querystring. This configurability is important, since path rewriting could make subfolder-based web.config authorization settings on image files have no effect.
3. Allow client caching time to be configurable. This will keep requests down, since clients won’t check for updates until the specified amount of time expires.
4. Make both server-side memory and disk caching invalidate when the source file changes.
5. Allow a easily extensible and large set of commands, affecting the cropping/sizing, visual effects, color choices/border/padding, and image output format/compression.
6. Prevent DOS attacks by limiting the disk cache to a configurable number of images.
7. Allow easy watermarking or post-processing of resized images

Overview of classes

With these goals in mind, I found it optimal to segment the logic into the following classes. While you may question my decision to split querystring parsing into 4 classes, it resulted in much cleaner code, and a much more usable interface for image manipulation from other classes.

• InterceptModule
  IHttpModule that checks for relevant requests during PostAuthorizeRequest, caches the ImageManger-proccessed images using DiskCache, and rewrites the request to the cached file. It also sets HTTP caching headers later in PreSendRequestHeaders. The disk-cached filename is an SHA256, base16 encoded hash of the request URL. Although the image is coming from a different file, the user never sees the URL of the cached file – the original filename is maintained.
• DiskCache

  Completely abstracts away disk caching, cleanup, and the associated threading issues. InterceptModule calls method UpdateCachedVersionIfNeeded(sourceFile,cachedFile, delegate updateMethod, int fileLockTimeout) with ImageManager.getBestInstance().BuildImage(sourcePath, cachedPath, queryString); as the contents of the delegate. DiskCache performs the modified date checks, cache cleanup, and thread locking to prevent the same image from being resizied by two different threads at the same time (it happens frequently!). The delegate is only executed if the cached file needs to be created or updated.

• CustomFolders
  Exposes a single method, static string processPath(string filePath, NameValueCollection q). This allows both URL rewriting and modifications to the querystring, such as /resize(w,h)/ syntax. InterceptModule simply calls this once prior to checking the querystring for valid commands.
• ImageManager

  exposes several overloads of a method called BuildImage() which allow both querystring and settings class configuration, and both bitmap and filename source and output. While BuildImage performs all the actual GDI calls, the querystring parsing, mathematics, and image writing are handled by other classes below.

• ResizeSettings(querystring)
  Accepts a single NameValueCollection (Querystring) as the constructor argument. Stretch, crop, scale, flip, sourceFlip, width, height, maxwidth, and maxheight are parsed into member variables. Exposes a ImageSizingData CalculateSizingData(SizeF originalImageSize, SizeF maxBounds) method that handles all mathematics. ImageSizingData includes the source rectangle on the image to copy from, the destination polygon for the image data, and a polygon that includes any whitespace.
• ImageOutputSettings(querystring)

  Parses the format, colors, and quality commands. It also exposes a SaveImage(Stream s, Image i) method that handles the writing of the various image types based on the querystring arguments. Static methods for saving images are also available.

• ImageSettings(querystring)
  Parses the bgcolor, paddingWidth, paddingColor, borderWidth, and borderColor commands. BuildImage() uses this data when drawing the image.
• WatermarkSettings(querystring)
  allows for custom drawing on images. It exposes a ModifySettings(ResizeSettings rs, ImageSettings opts, ImageFilter adjustments, ImageOutputSettings ios) method for adjusting settings prior to resizing, and a Process(Bitmap b, Graphics g) method for post-processing of resized images.

InterceptModule code

I hope this overview is clear enough – if not, please leave a question below. Understanding the design, the source code for InterceptModule should now make sense. Thankfully, this is one of the shortest classes, but it should help you write your own HttpModule. I’ve removed the class declaration, imports, and profiling code for clarity. The original source code comments explain everything pretty clearly.

/// <summary>
/// This is where we filter requests and intercet those that want resizing performed.
/// We first check for image extensions...
/// If it is one, then we run it through the CustomFolders method to see if if there is custom resizing for it..
/// If there still aren't any querystring params after that, then we ignore the request.
/// If the file doesn't exist, we also ignore the request. They're going to cause a 404 anyway.
///
/// </summary>

/// <param name="sender"></param>
/// <param name="e"></param>
protected virtual void CheckRequest_PostAuthorizeRequest(object sender, EventArgs e)
{
	//Get the http context, and only intercept requests where the Request object is actually populated
	HttpApplication app = sender as HttpApplication;
	if (app != null && app.Context != null && app.Context.Request != null)
	{

		//Is this an image request? Checks the file extension for .jpg, .png, .tiff, etc.
		if (ImageOutputSettings.IsAcceptedImageType(app.Context.Request.FilePath))
		{
			//Init the caching settings. These only take effect if the image is actually resized
			//CustomFolders.cs can override these during processPath
			app.Context.Items["ContentExpires"] = DateTime.Now.AddHours(24); //Default to 24 hours
			string cacheSetting = ConfigurationManager.AppSettings["ImageResizerClientCacheMinutes"];
			if (!string.IsNullOrEmpty(cacheSetting)){
				double f;
				if (double.TryParse(cacheSetting,out f)){
					if (f >= 0)
						app.Context.Items["ContentExpires"] = DateTime.Now.AddMinutes(f);
					else
						app.Context.Items["ContentExpires"] = null;
				}
			}

			//Copy the querystring
			NameValueCollection q = new NameValueCollection(app.Context.Request.QueryString);

			//Call CustomFolders.cs to do resize(w,h,f)/ parsing and any other custom syntax.
			//The real virtual path should be returned (with the resize() stuff removed)
			//And q should be populated with the querystring values
			string basePath = CustomFolders.processPath(app.Context.Request.Path, q);

			//If the path has changed, this will circumvent the URL auth system.
			//Make sure the user has explicity allowed it through web.config
			if (!basePath.Equals(app.Context.Request.Path))
			{
				//Make sure the resize() notation is allowed.
				string allow = ConfigurationManager.AppSettings["AllowURLRewriting"];
				if (string.IsNullOrEmpty(allow)) allow =ConfigurationManager.AppSettings["AllowFolderResizeNotation"];
				if (string.IsNullOrEmpty(allow) || allow.Equals("false", StringComparison.OrdinalIgnoreCase)){
					return; //Skip the request
				}
				//Prevent access to the /imagecache/ directory (URL auth won't be protecting it now)
				if (new yrl(basePath).Local.StartsWith(DiskCache.GetCacheDir(), StringComparison.OrdinalIgnoreCase))
				{
					throw new HttpException(403, "Access denied to image cache folder.");
				}
			}
			//See if resizing is wanted (i.e. one of the querystring commands is present).
			//Called after processPath so processPath can add them if needed.
			//Checks for thumnail, format, width, height, maxwidth, maxheight and a lot more
			if (ImageManager.getBestInstance().HasResizingDirective(q))
			{
				//Build a URL using the new basePath and the new Querystring q
				yrl current = new yrl(basePath);
				current.QueryString = q;

				//If the file exists, resize it
				if (current.FileExists)
					ResizeRequest(app.Context,current);

			}
		}
	}
}

/// <summary>

/// Builds the physical path for the cached version, using the hashcode of the normalized URL.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
protected string getCachedVersionFilename(yrl request)
{
	string dir = DiskCache.GetCacheDir();
	if (dir == null) return null;
	//Build the physical path of the cached version, using the hashcode of the normalized URL.
        //We don't use String.GetHashCode(), since it returns a 32-bit integer. Chances of a hash collision are low, but possible.
        // So, we use a 256-bit hash instead.
	SHA256 h = System.Security.Cryptography.SHA256.Create();
	byte[] hash = h.ComputeHash(new System.Text.UTF8Encoding().GetBytes(request.ToString().ToLower()));
	//Can't use base64 hash... filesystem has case-insensitive lookup.
	//Would use base32, but too much code to bloat the resizer. Simple base16 encoding is fine
	return dir.TrimEnd('/', '\\') + "\\" + Base16Encode(hash) + "." + new ImageOutputSettings(request).GetFinalExtension();
}
/// <summary>

/// Returns a lowercase hexadecimal encoding of the specified binary data
/// </summary>
protected string Base16Encode(byte[] bytes)
{
	StringBuilder sb = new StringBuilder(bytes.Length * 2);
	foreach (byte b in bytes)
		sb.Append(b.ToString("x").PadLeft(2, '0'));
	return sb.ToString();
}

/// <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="r"></param>
/// <param name="extension"></param>

protected virtual void ResizeRequest(HttpContext context, yrl current)
{
	//This is where the cached version goes
	string cachedFile = getCachedVersionFilename(current);

	//Disk caching is good for images because they change much less often than the application restarts.

	//Make sure the resized image is in the disk cache.
	bool succeeded = DiskCache.UpdateCachedVersionIfNeeded(current.Local, cachedFile,
		delegate(){

			//This runs if the update is needed. This delegate is preventing from running in more
			//than one thread at a time for the specified source file (current.Local)
			ImageManager.getBestInstance().BuildImage(current.Local, cachedFile, current.QueryString);
		},30000);

	//If a co-occurring resize has the file locked for more than 30 seconds, quit with an error.
	if (!succeeded)
		throw new ApplicationException("Failed to acquire a lock on file \"" + current.Virtual +
                                              "\" within 30 seconds. Image resizing failed.");

	//Get domain-relative path of cached file.
	string virtualPath = yrl.GetAppFolderName().TrimEnd(new char[] { '/' }) + "/" + yrl.FromPhysicalString(cachedFile).ToString();

	//Add content-type headers (they're not added correctly when the source URL extension is wrong)
	//Determine content-type string;
	string contentType = new ImageOutputSettings(current).GetContentType();

	context.Items["FinalContentType"] = contentType;
	context.Items["FinalCachedFile"] = cachedFile;

	//Rewrite to cached, resized image.
	context.RewritePath(virtualPath, false);
}
/// <summary>

/// We don't actually send the data - but we still want to control the headers on the data.
/// PreSendRequestHeaders allows us to change the content-type and cache headers at excatly the last
/// second. We populate the headers from context.Items["FinalContentType"],
/// context.Items["ContentExpires"], and context.Items["FinalCachedFile"].
/// This also indirectly enables server-side mem caching. (HttpCacheability.Public does it)
/// We set the file dependency to FinalCachedFile so changes are update quickly server-side
/// - however, clients will not check for updates until ContentExpires occurs.
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>

protected void context_PreSendRequestHeaders(object sender, EventArgs e)
{
	HttpApplication app = sender as HttpApplication;
	HttpContext context = (app != null) ? app.Context : null;
	//Check to ensure the context and Response is in good shape (it's needed)
	if (context != null && context.Items != null && context.Items["FinalContentType"] != null
                          && context.Items["FinalCachedFile"] != null)
	{
		//Clear previous output
		//context.Response.Clear();
		context.Response.ContentType = context.Items["FinalContentType"].ToString();
		//Add caching headers
		context.Response.AddFileDependency(context.Items["FinalCachedFile"].ToString());

		//It's not UTC - server time zone.
		if (context.Items["ContentExpires"] != null)
			context.Response.Cache.SetExpires((DateTime)context.Items["ContentExpires"]);

		//Enables in-memory caching
		context.Response.Cache.SetCacheability(HttpCacheability.Public);
		context.Response.Cache.SetLastModifiedFromFileDependencies();
		context.Response.Cache.SetValidUntilExpires(false);
	}

}

I’m sure a lot of people will think I’m nuts for posting the source code to the main class of my image resizer,
but I know that this will help a lot of people.

Based on the response I get to this article, I may continue with additional parts. I would like to cover the math behind scaling and cropping, the GDI bugs, and maybe even image output/compression.

Hope this helps!
Nathanael

Installation is the same as for the full version.

Download Trial version and sample project (4MB)

When you upgrade to the full version, remember to delete the imagecache directory, or you will continue to see the word “Unlicensed” on old pictures.

So why am I writing another?

Because each article I have read includes one of the errors below, leading readers to write either
slow, insecure, or incorrectly functioning code. I have discovered many of these pitfalls the hard way.
I hope others won’t have to.

Instead of giving step-by-step instructions, this article will simply list pitfalls and the alternatives. I hope to publish my approach in a Part 2.

Security and Performance Pitfalls

1. Not using using(){}. You *must* wrap your Graphics, Bitmap, and MemoryStream objects
   in a using(){} clause, or else they will not get cleaned out of memory for a while.
   Under load this can cause *serious* issues. Read
   
   to dispose, or not to dispose, that’s the 1GB question if you have
   any doubts regarding the severity of this error.

   If you find yourself nesting a lot of using(){} statements, you can also use equivalent try{}finally{} code.

   //Using method. object must implement IDisposable for this to work
   using (object a = new object())
   {
       using (object b = new object())
       {
           using (object c = new object())
           {
   
           }
       }
   }
   
   //Try finally method
   object a = null;
   object b = null;
   object c = null;
   try
   {
       a = new object();
       b = new object();
       c = new object();
   }
   finally
   {
       if (a != null) a.Dispose(); //If one of the Dispose methods throws an error, the others will not execute.
       if (b != null) b.Dispose(); //So there is an advantage to using nested using(){} clauses
       if (c != null) c.Dispose(); //You could nest try{} finally{ try{} finally{ try{} finally{}}} to solve that...
       //Two different techniques - take your pick
   }
   

2. Using on-the-fly image resizing without disk caching! The ASP.NET
   memory cache won’t cut it here folks – it gets cleaned out every application reboot,
   and besides, you probably have more images than RAM. Resizing an image is fast,
   but it will still flood the CPU if a single user browses a single page with 20 or more
   resized images on it. This is a do-it-yourself
   DOS attack. On-the-fly resizing is fine if you have disk caching.
3. Not using on-the-fly resizing. This one bites also. If you decide to convert all
   your images up-front, please realize how difficult it will be to track down the
   originals and resizing them again next time you make a resolution jump. I’ve been
   through this enough, and it’s painful – that’s why I wrote a dynamic image resizer!
4. Disk-caching without checking for updated (or reverted!) source files. Debugging
   a resized image that won’t update can eat up lots of time. Make sure you set the
   LastWriteTimeUTC on your cached images to match the source image file (and check
   they match) – don’t simply check to see if the source file is newer than the cached
   file, since that will break if you copy an older file over a source image. Always
   use something like RoughCompare() to compare filesystem dates – *never* inequalities.
   Remember that filesystem dates are less precise than DateTime, and get rounded.

   /// <summary>
   /// Returns true if both dates are equal (to the nearest 200th of a second)
   /// </summary>
   /// <param name="modifiedOn"></param>
   /// <param name="dateTime"></param>
   /// <returns></returns>
   private static bool RoughCompare(DateTime d1, DateTime d2)
   {
   	return (new TimeSpan((long)Math.Abs(d1.Ticks - d2.Ticks)).Milliseconds <= 5);
   }
   

5. Disk-caching without cleanup! Another do-it-yourself
   DOS attack, although not quite as bad as the first. Left unchecked, your cache
   directory could grow very large over a few years as orphaned
   image versions accumulate. If a malicious visitor realizes that you have automatic resizing,
   he could try to fill up your hard drive by requesting an endless variety of resolutions
   for a given image. Of course, security-conscious developers will have cache-limiting
   systems in place. I suggest cleaning out the least recently used 10-20% of the cache
   directory whenever the file limit is reached. Handle locked files gracefully.
6. Checking the cache size for cleanup every image request. This will swamp your I/O.
   Instead of running that directory listing each time, keep a static counter that tracks how many new images have been resized
   since the application started. Run the cache cleanup on the first image request and each time the counter passes the cleanup threshold.
7. Disk caching without protecting the cache directory. Unless you want anonymous users to potentially view the same images
   as authorized users, you need your cache directory locked down. A Web.config file in the directory can do this – just verify your URL rewriting rules
   don’t leave another way to access the directory.

   The cache directory needs to stay inside the application to permit request rewriting to the cached files.

8. Disk caching without proper locking code. This is a minor problem, since the
   consequences are light – but it is good to remember that 2 image requests for the
   same image size could happen at the same time, and (if they aren’t cached), they
   may conflict when trying to write to the same file at the same time. You’ll probably
   get a “The process cannot access the file because it is being used by another process.”
   message if this happens. You can prevent this by creating a locking system so that
   only one thread can save a give resized image at a time. Optimally, you want multiple resizes for different images to occur at the same time. If you’re
   not as concerned about concurrency performance as I was, you could cheat at make the whole resizing method locked. (For new image requests only!)
9. Writing directly to the output stream. If you’re caching to disk, but still serving
   the image contents in code, you’re only supporting a little bit of the HTTP standard,
   and you’re bypassing all of the work Thomas
   Marquardt did to bring StaticFileHandler up to snuff . Implement your resizer
   as and HttpModule, not an HttpHandler or you’re stuck.
10. Serving a file from disk by loading it into memory. Think about how much RAM your server has,
    how large a single image is, how long
    it has to stay in memory before users finish downloading it, and how many users
    you have requesting images. Don’t load anything into memory after the initial resize.

    WriteFile()
    serves directly from disk, and is *much* safer and more efficient. However – you
    shouldn’t be using WriteFile() either if you can avoid it. Letting StaticFileHandler
    do its job is a much better choice.

11. Making an HttpHandler instead of an HttpModule. I actually did this in
    v1.0, and it was a *mess*, as well as being non-optimal from a performance standpoint.
    There are several problems with doing this as an HttpHandler.
    1. It’s very difficult to make an HttpHandler catch only *some* requests (i.e., those
       requesting resizing), for a certain extension. It’s very hard, in fact, and involves
       subclassing DefaultHttpHandler and re-implementing a lot of code. While that’s possible
       on IIS5/6/7 classic, it doesn’t work on IIS7 Integrated. So IIS7 integrated is a
       complete deal-breaker if you want to let standard images alone.
    2. It’s difficult to pass a request from one HttpHandler to another. When building
       an image resizer, we don’t want to be responsible for serving the resized file,
       just making sure the resized version has been cached to disk, and then rewriting
       the request to point to that file. An HttpModule, on the other hand, is perfectly
       suited to checking for image resize requests, caching the results, and rewriting
       the request so StaticFileHandler or whatever is the default in IIS 8 , 9, or 10
       can take of it. I do this in PostAuthorizeRequest, by calling context.RewritePath(virtualPath, false);
12. Not setting context.Response.ContentType properly. You’ll get all kinds of interesting,
    varied, and peculiar results from browsers if you omit this step. Things can be really
    interesting if the format is changed during the resize, since the extension will
    match the original format.
13. Obvious, but you should have caching enabled for your images, regardless
    of whether they are being resized or not. Disk caching is great, but memory caching allows for even faster responses to frequently requested images, and shouldn’t be omitted.
    In addition, HttpCacheability.Public enables client and proxy caching too, so browsers and some firewalls will cache the result from the server. You can adjust the amount of time
    the files are cached with SetExpires.

    This is the code I use during PreSendRequestHeaders

    HttpApplication app = sender as HttpApplication;
    HttpContext context = (app != null) ? app.Context : null;
    
    if (context != null && context.Items != null && context.Items["FinalContentType"] != null && context.Items["FinalCachedFile"] != null)
    {
    	//Clear previous output
    	//context.Response.Clear();
    	context.Response.ContentType = context.Items["FinalContentType"].ToString(); //FinalContentType is set to image/jpeg or whatever the image mime-type is earlier in code.
    	//Add caching headers
    	context.Response.AddFileDependency(context.Items["FinalCachedFile"].ToString());
    
    	if (context.Items["ContentExpires"] != null)
    		context.Response.Cache.SetExpires((DateTime)context.Items["ContentExpires"]); //ContentExpires is set to DateTime.Now.AddMinutes(x), where x is how long the clients should locally cache the image before checking for updates.
    
    	//Enables in-memory caching
    	context.Response.Cache.SetCacheability(HttpCacheability.Public);
    	context.Response.Cache.SetLastModifiedFromFileDependencies();
    	context.Response.Cache.SetValidUntilExpires(false);
    }
    

14. Accepting the file path as a querystring parameter. This mistake makes me cringe
    – I find it amazing each time how much people trust their filtering code to prevent
    abuse of this feature. (If they have path filtering code at all!) Just… don’t…
    do it… please. Do you know how many ways there are to encode filenames and circumvent
    pattern-matching techniques? Yes, there are ways to protect this kind of system, but why?

    Why choose /resizeimage.ashx?path=~%2fimg%2fproducts%2fbox.jpg&maxwidth=100&maxheight=100
    over /img/products/box.jpg?maxwidth=100&maxheight=100 ?

    If you’re stuck in IIS6 and you aren’t allowed to modify handler mappings, you should look for a better host.

Pitfalls in Image Resizing

1. Using GetThumbnailImage().
   GetThumbnailImage() seems the obvious choice, and many articles recommend its
   use.
   Unfortunately, it always grabs the embedded jpeg thumbnail if present.
   Some photos have these, some don’t – it usually depends on your camera. You’ll wonder
   why GetThumbnailImage works good on some photo, but on others is horribly
   blurred. GetThumbnailImage() isn’t reliable for photos larger than 10px by 10px for that reason.
2. Forgetting to set InterpolationMode, SmoothingMode, CompositingQuality, and PixelOffsetMode.
   With all these set properly, you
   should be able to get resized images indistinguishable from Photoshop results. If
   you don’t, you’ll end up with trash. GDI has dumb defaults. (BTW, the low-quality
   settings aren’t always much faster)
   This article explains why those are needed to make DrawImage compose the
   image well.

   graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
   graphics.SmoothingMode  = SmoothingMode.HighQuality;
   graphics.CompositingQuality = CompositingQuality.HighQuality;
   graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
               

3. Not maintaining aspect ratio. I see this often, and I’m not sure why – the math
   isn’t too hard. Well, for those who are wondering how, I hope this code is rather
   transparent (no pun intended).

   double aspectRatio = imageWidth/imageHeight;
   double boxRatio = maxWidth/maxHeight;
   double scaleFactor = 0;
   if (boxRatio > aspectRatio)
    //Use height, since that is the most restrictive dimension of box.
    scaleFactor = maxHeight / imageHeight;
   else
    scaleFactor = maxWidth / imageWidth;
   
   double newWidth = imageWidth * scaleFactor;
   double newHeight = imageHeight * scaleFactor;
   

4. Not setting the Jpeg quality to 90. You’ll get huge Jpegs from Image.Save unless
   you pass in the proper parameters. 90 seems to be the magic value – great quality
   and much lower file size than 100.

   int quality = 90; //90 is the magic setting - really. It has excellent quality and file size.
   System.Drawing.Imaging.EncoderParameters encoderParameters = new System.Drawing.Imaging.EncoderParameters(1);
   encoderParameters.Param[0] = new System.Drawing.Imaging.EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)quality);
   thumb.Save(stream, GetImageCodeInfo("image/jpeg"), encoderParameters);
   
   /// <summary>
   /// Returns the first ImageCodeInfo instance with the specified mime type. Some people try to get the ImageCodeInfo instance by index - sounds rather fragile to me.
   /// </summary>
   /// <param name="mimeType"></param>
   /// <returns></returns>
   public static ImageCodecInfo GetImageCodeInfo(string mimeType)
   {
   	ImageCodecInfo[] info = ImageCodecInfo.GetImageEncoders();
   	foreach (ImageCodecInfo ici in info)
   		if (ici.MimeType.Equals(mimeType, StringComparison.OrdinalIgnoreCase)) return ici;
   	return null;
   }
   

5. Using the built-in quantization (palette creation) for GIFs, 8-bit PNGs and BMPs.
   The default palette is truly terrible, and while you can specify your own set of
   255 colors – which ones should they be? The process of determining which colors
   to choose for the palette and to produce the best quality images is call quantization.
   I recommend the very efficient and decent-quality
   octree quantization algorithm. It does have a number of bugs you will have
   to patch. Follow the transparency patch instructions found in the comments. Use the safe version of the library. Patch the Marshal.ReadInt32() bug (original is ReadByte()).
   Change any casts from IntPtr->int to IntPtr->long to make the code 64-bit safe.

   I’m working on adding adjustable Floyd-Steinberg dithering to the version in my resizer , and
   the results have been very promising so far.

6. Inheriting the palette from the original image. While at first this seems like an
   
   easy way to solve the palette problem for GIFs, realize that the bicubic
   resizing will have combined colors, and the new thumbnail may not have any of colors
   of the original image. Also, any operations performed on the bitmap in 8-bit mode
   will be poor quality, and this won’t allow conversion between image formats. There are
   other ways to keep transparency. This is probably better than leaving the default palette, but YMMV.
7. Resizing images that don’t request it. Your code should only activate when an image has a querystring with one of the supported
   commands. Pushing all images through your code is unnecessary.
8. And one last piece of advice. Have Good Defaults. Always.

   The output image type should default to the source image type, unless it’s a BMP or TIFF.
   Default behavior should always preserve aspect ratio.

   Many developers stop after making their code configurable. They don’t take that extra 10 minutes to give
   everything smart defaults. Smart defaults distinguish good software from great software.

I hope to post Part 2 soon. I plan on revealing the architecture that has evolved in my resizer,
and how to design a IIS5/6/7 compatible HttpModule.

• When both ?width=x&height=y are specified, the default behavior has changed. Instead of stretching the image and losing aspect ratio, whitespace is added (controlled with &bgcolor=color name|code). You can reinstate the original behavor by adding &stretch=fill. Based on customer feedback.
• ICC profiles are now read on source images, but changes are merged into the image before output. Since most browsers (including Firefox) do not read ICC profiles, this should produce consistent cross-browser behavior. If you want to ignore the original ICC profile for an image, add &ignoreicc=true.
• The CustomFolders.cs format has changed, and is now much, much more powerful. All querystring commands can be used, and URL rewriting can be performed. (AllowURLRewriting must be true).

New features

Check out the samples page to see these features in action.

• Automatic cropping and centering can be performed with ?crop=auto&width=x&height=y. You can also choose a crop rectangle from the source image manually with &crop=(x1,y1,x2,y2). Negative values indicate distances relative to the bottom-right corner. (10,10,-10,-10) would crop a 10-pixel border off the source image.
• Support for 8-bit PNG file output with &colors=2-255. Sets the palette size for both PNG and GIF images.
• GIF and 8-bit PNG files are now much, much better. Instead of using the GDI default palette, octree quantization is used to calculate the optimal color palette for each image.
• Upscaling can be enabled using &scale=both. The default is &scale=downscaleonly. &scale=upscaleonly is also available for certain zooming situations.
• Image rotation is supported in degrees. Ex. &rotate=45. Image sizing is performed before rotation, so rotation will cause the final image size to be larger than the size specified in the querystring.
• Image flipping can be performed using &flip=h|v|both. To flip the source image before other commands occur, use &sourceFlip=h|v|both.
• BMP and TIFF source files are now supported.
• You can add padding around the image with &paddingWidth=px&paddingColor=color|hex. paddingColor defaults to bgcolor, which defaults to white.
• You can add a border around the image with &borderWidth=px&borderColor=color|hex.
• Transparency is maintained while resizng PNG files, and when converting from PNG to GIF.
• DisableCacheCleanup=true|false is now supported in Web.config. If you have plenty of disk space and wish to manually purge old files from the cache, this setting will allow it. Leave the default value to false unless you have a very good reason.
• DiskCacheAlwaysInvalid=true|false is a new Web.config setting for debugging. It forces every request to update the disk cache before responding. Very, very slow, so make *sure* this is false before you launch.
• Websites located on UNC paths are now supported. (Ex. \\server\share\website).

Installation

1. Replace the old files with the new files from the ImageResizer folder. If you are using the .DLL, replace the DLL in the bin folder. Keep a copy of your old CustomFolders.cs if you have modified it.
2. Delete the /imagecache directory.
3. If you use both width and height to stretch any images, add &stretch=fill to those URLs to maintain the same behavior.
4. Migrate CustomFolders.cs if you have modified it. The new file includes source comments explaining the process.

If you haven’t upgraded to 1.2, follow these instructions first

Hover over the images to view the querystrings used. All commands can be combined.

Resizing using maxwidth and/or maxheight

Aspect ratio is always maintained with maxwidth and maxheight. The image is scaled to fit within those bounds.

Resizing using width and height

Specifying only one of width or height will behave the same as using maxwidth
or maxheight. The difference is when you specify both.

Specifying both width and height will force the image to those exact dimensions, unless the
image is already smaller (see scale). This is done by adding whitespace to the image. To center and crop instead, use
&crop=auto. To lose aspect ratio and fill the specified rectangle, use &stretch=fill.

Scaling

By default, images are not upscaled. If an image is already smaller than width/height/maxwidth/maxheight, it is not resized.
To upscale images, use ?scale=both. ?scale=downscaleonly is the default.

The slight blur around the edges is a bug in Graphics.DrawImage(). You can control the color by setting &bgcolor=color|hex.

Cropping

To enable cropping, you can use &crop=auto, which minimally crops and centers to preserve aspect ratio, or custom cropping.

&crop=(x1,y1,x2,y2) specifies the rectangle to crop on the image. You can still resize and modify the cropped portion
using the other commands as normal. Negative coordinates are relative to the bottom-right corner –
which makes it easy to trim off a 50-pixel border by specifying &crop=(50,50,-50,-50).

Rotation

Rotation is easy – just specify the number of degrees. You may want to set bgcolor also.

Flipping

You can horizontally or verically flip an image, as well as both. &flip=h|v|both

Source flipping

Since normal flipping applies after rotation and cropping occur, it can be
difficult to work with if you are just wanting the source image flipped before the other
adjustments are applied. To flip the source prior to work, use &sourceFlip=h|v|both.

Note how the same crop coordinates return different sections of the image. This is because the source image is flipped before *anything* happens.

Stretching

To stretch an image to width and height, use &stretch=fill.

Padding

You can add padding around the image with &paddingWidth=px and
&paddingColor=color|hex. paddingColor defaults to bgcolor, which defaults to white.
This setting can be…. useful.

Borders

You can add a border around the image with &borderWidth=px,
&borderColor=color|hex.

Output format

GIF, JPG, and PNG output is supported. BMP and TIFF input fils are additionally supported, and every format can be converted to any other format with &format=jpg|png|gif

Jpeg compression levels 0-100 (&quality=0-100)

The sizes of these images range from 855B to 12KB. The largest size jump is from 90 to 100 (5KB to 12KB). I think 90 is a good balance, and is therefore the default.

Quantization (8-bit PNG and GIFs)

The default GDI quantization is terrible, and produces lousy GIFs. Using the Octree quantizer, you can
control the number of colors (and therefore the size and quality) of an image using &colors=2-255

GIFs, in 4,8,16,32,64,128, and 256 colors

PNGs, in 4,8,16,32,64,128, 256, and 16 million colors

Transparent GIFs and PNGs

Transparency is maintained when resizing PNGs

Matte backgrounds can be applied with bgcolor.

Transparent PNGs can be converted to transparent GIFs

It’s ugly, but GIFs only get 1 bit for transparency.

Single frames can be extracted from animated GIFs with &frame=x

/resize(width,height,format)/ syntax

For the URL-conscious, you can replace img/image.jpg?maxwidth=x&maxheight=y with
img/resize(x,y)/image.jpg. A third argument, format, is also allowed.

However, enabling this (AllowURLRewriting) will make the ASP.NET URL authorization system unable to match URLs…. But that only affects you if you set permissions in web.config.

Disk I/O is responsible for almost all slow websites and desktop applications. It’s true. Watch your CPU use next time you open a program, or your server is under load. CPUs aren’t the bottleneck anymore – your hard drive is. At the hardware level, the hard drive is the slowest component by an incredibly large factor. Today’s memory ranges between 3200 and 10400 MB/s. In contrast, today’s desktop hard drive speeds average about 50 MB/s (Seagate 500GB), with high-end drives getting 85MB/s (WD 640, Seagate 1TB). If you’re looking at bandwidth, hard drives are 200-300 times slower. Bandwidth, though, isn’t the killer – it’s the latency. Few modern hard drives have latencies under 13 milliseconds – while memory latency is usually about 5 nanoseconds – 2,000 times faster.

You’re probably looking at these numbers and thinking, “13ms is quite fast enough for me, and my app is only dealing with small files”. However, I have a question: what other applications are using that drive? If you’re on a shared server, the odds are high that between 25 and 2500 ASP.NET apps are being run on the same drive.

CPU, bandwidth, and memory throttling is becoming more and more common on shared servers and virtualization systems, but practical disk throttling isn’t even on the horizon from what I can tell. Improper I/O usage from any app affects everybody.

Since hard drives are slow, pending operations go into a queue. So even if your app only needs a single byte of data from the hard drive, it still has to wait its turn. It’s quite common for disk operations to take several seconds on a shared server under heavy load. If any application on the server is paging to disk from exessive memory use, it can take several minutes, causing a timeout.

Realistic I/O performance is really hard to simulate in a development environment. On a dedicated development machine, disk queues are short, and response times are usually near the optimal 13ms, which tends to give software developers gravely incrorrect ideas about the performance characteristics of their application.

Load test!

A good way to acid test your code is to run it on a cheap, overloaded shared server. Webhost4life.com has $10/month plans that are excellent for this purpose. I’m actually using Webhost4life.com for this site, and while I/O calls consistently take around 1 second each, page views are decently quick since everything is in memory. I can’t seem to get more than 30-40KB/s bandwidth though, so I’m probably going to switch hosts soon.

Stress testing can also be accomplished with load testing tools like the Web Application Stress Tool. Getting realistic results often means multiplying user load by a factor of 1000 or more, since I/O speeds can vary by that much on a production server. So, if you want to handle 50 concurrent users gracefully, test with 50,000.

One good way to make sure your app can handle high load is to get your per-request time very low. There is an extension for Firefox that provides TTFB (time-to-first-byte) information that will help you measure this. (Trace.axd is an invaluable tool here also). If requests complete in 13 milliseconds, the odds are good that you can handle 100 of those requests per second.

Cache smart

It’s not too hard to cache files in memory. Here’s one approach that uses ASP.NET’s built in caching system:

namespace fbs.Filesystem
{
    /// <summary>
    /// Provides cached read access to small, frequently used files. Use carefully!
    //// Uses HostingEnvironment.Cache (same as app cache).
    /// </summary>
    public static class CachedFileAccess
    {
        /// <summary>
        /// Retrieves the file from the cache, or from disk if neccessary. Exceptions from IO.File.ReadAllText are not caught.
        /// Make sure the file exists and can be accessed before attempting this function.
        /// </summary>
        /// <param name="file">Standard pathname (C:\..</param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static string ReadAllText(string file, Encoding encoding)
        {

            if (HostingEnvironment.Cache == null) throw new InvalidOperationException("HostingEnvironment.Cache is null");
            string key = "cached_file(" + encoding.EncodingName + ")_" + file.ToLowerInvariant().GetHashCode();

            string value = HostingEnvironment.Cache[key] as string;
            if (value == null)
            {
                value = System.IO.File.ReadAllText(file, encoding);
                HostingEnvironment.Cache.Add(key, value, new System.Web.Caching.CacheDependency(file),
                    System.Web.Caching.Cache.NoAbsoluteExpiration, System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.Low,null);

            }
            return value;
        }
    }
}

If you must do I/O, File.Exists and File.GetLastWriteTimeUtc are much faster that actually opening a file. The filesystem ‘tables’ are often cached in memory, and therefore have much higher average performance.

Don’t do memory leaks. In-memory caching is good, but if you have a memory leak the app’s memory space will get moved to disk, effectively slowing all memory access down the hard disk speeds. Not good. And you’re going to kill everyone else on the same disk. Make sure there is a finite and reasonable limit to what will be cached (especially if you’re using static variables instead of the ASP.NET cache object).

Asynchronous=good, synchronous=evil.

In any application, asynchronous IO calls should be used whenever possible. There’s a reason that I/O and web service calls in well-built applcations are async – it is impossible to predict how long I/O operations will take. Any hard drive operation can take seconds to minutes – and there is no way to insure a responsive experience to users unless you make sure all I/O calls are out-of-band.

One nice thing about the web is that HTTP request are by nature async – so if you have any I/O calls that *must* be made, you can do them with AJAX later instead of holding up the entire page while they execute.

Databases are a Good Thing

Databases are Good. Build the right indexes, and queries will be quick. Most engines cache as much data as possible in memory (usually indexes get priority caching), so a well-designed database will almost alwasy beat standard I/O.

Hybrid approaches can get the best of both worlds

Being able to edit your files on disk is really nice – it tempts people away from database-driven websites all the time. But – you can have both ease-of-use and performance. nathanaeljones.com can be completely managed through an FTP connection and Notepad, if needed. It’s nice to drag-and drop files when I need to upload a bunch. It’s nice to use VS when I want to do some tricky coding.

Every few minutes, a ~1.5 second syncronization routine does a quick GetLastWriteTimeUTC check on the .aspx files that start with an ID, and pushes any changes to the database. The database is read only – basically a cache of the filesystem. But it allows instant, flexible querying/searching of all the articles, and provides the best of both worlds.

I don’t edit files manually much anymore, although it does come in handy. Right now I’m using the web-based article editor to write this – most of my work occurs through my online ASP.NET markup editor. But for those who like the comfort of Dreamweaver or VS, they can edit their articles in WYSIWYWYG mode all day long

It can be difficult to write a filesystem to database synchronization system properly – there are a lot of wrong ways to go about it. Done properly, it can scale up to at least 50,000 articles. The routine must be located on a separate thread, and must use a ReaderWriterLock to prevent reads while database is build batch updated with SqlBulkCopy calls. A single call is used to get the listing of .aspx files: System.IO.Directory.GetFiles(appRoot, “*.aspx”, System.IO.SearchOption.AllDirectories); A database call downloads the paths and last-modified dates from the database, and the two are cross-referenced to compile a list of created, moved, changed, and deleted files. These changes are then commited to the database using SqlBulkCopy, as well as being logged. Changed files are compared with the SQL copy to generate a Diff report for the log.

Filesystem state

Another factor in disk performance is the state of the filesystem. While filesystems are usually built using very smart algorithms, all algorithms slow down as they have to crunch more data. The more files you get on a disk, the slower file lookup and access becomes. I’ve compared identical 15k disks with no difference except the number of files, and the response time difference would almost make you suspect the one with 500,000 files to be a floppy drive.

In conclusion

Disk performance slightly increases each year and SSDs are promising, but physical disks never seem to catch up to our need for space and speed. I/O operations on shared or highly-active servers will probably be slow for many years to come.

Think carefully before you use System.IO, and make sure there aren’t any alternatives. Pretend you’re calling a web service each time you use the File class, and be kind to your users.

Say NO to IO

Here’s how to add metadata and stylesheet management by making a subclass which we’ll call PageBase, since all markup pages will inherit from it.

Features

• One-line method calls for common operations like adding a stylsheet reference or changing metadata.
• Duplicate stylsheet/meta tag prevention.
• Only 2 instance members will be added to PageBase – .Stylesheets and .Metadata.
  Stylesheet (HtmlLink) and Metadata (HtmlMeta) management is encapsulated in separate classes to keep things clean, and reduce methods inside the page class.
• Static PageBase.GetControlsOfType<t>(Control parent) method simplifies all kinds of hierarchy querying.

StylesheetManager methods

Complete documentation is in the XML comments in the code.

Page.Stylesheets.AddLink("~/css/effects/css","stylesheet", "text/css");
Page.Stylesheets.AddLink("~/css/effects/css"); //Shorter syntax for typcial usage
Page.Stylesheets.AddLinkIfMissing("~/css/effects/css"); //So User Controls and multi-instance objects can safely include stylesheets without worrying about duplicates.
Page.Stylesheets.RemoveLinks("~/css/effects/css"); //Removes all links matching this path (ResolveUrl() is called on all paths prior to comparison)
Page.Stylesheets.GetControls() //returns all HtmlLink controls within the page header.
Page.Stylesheets.GetHrefs() //Returns a collection of all hrefs from the link tags on the page.
Page.Stylesheets.FindLinkControl(string href); //Case-insensitive, ResolveURL-cleaned search by href value.

MetadataManager methods

Page.Metadata["description"] = "Why everybody ends up extending the Page class".
if (Page.Metadata["description"] == "Why everybody ends up extending the Page class"){}

// Returns a collection of all HtmlMeta controls in the header
// Calls  PageBase.GetControlsOfType<HtmlMeta>(_page.Header);
Page.Metadata.GetControls();
Page.Metadata.GetNameContentPairs(); //Returns a NameValueCollection of the metadata name/content pairs.
Page.Metadata.GetControl("description") // Returns the first HtmlMeta instance matching the specified name attribute
Page.Metadata.RemoveControls(List<HtmlMeta>) //Detaches each item in the collection from its parent
Page.Metadata.HideControls(List<HtmlMeta>) //Sets .Visible and .EnableViewState to "false" on all items.
Page.Metadata.GetMatches(query) //Returns all HtmlMeta instances with matching Name attributes. Query can be "*" or a comma-delimited list of values like "description,keywords,test"
Page.Metadata.GetNonMatches(quer) //Returns all non-matching HtmlMeta instances

Usage

We can use this base class in any page my making a single change.
If the page has a code-behind file, just change

public partial class _Default : System.Web.UI.Page

to

public partial class _Default : fbs.PageBase

If it is a standalone .aspx file, you can set Inherits="fbs.PageBase".

Internals

All of the querying operations performed only affect controls of a certain type. To greatly simplify the code for both StylesheetManager and MetdataManager, we have added GetControlsOfType<t>(Control parent) to the PageBase class.

This method efficiently builds a collection of all controls in the specified hierarchy that are of type T.

/// <summary>
/// Iterates over the control structure of the specified object and returns all elements that are
/// of the specified type
/// </summary>
/// <param name="parent"></param>
/// <returns></returns>
public static List<T> GetControlsOfType<T>(Control parent) where T : Control
{
	return GetControlsOfType<T>(parent, false,false);
}
/// <summary>
/// Iterates over the control structure of the specified object and returns all elements that are
/// of the specified type. If there are two items of the specified type, and one is a child of the other,
/// the childrenOnly and parentOnly parameters can be used to control which is selected. If both are false, both controls are returned.
/// </summary>
/// <param name="parent">The control to search</param>
/// <param name="childrenOnly">If true, only the innermost matching children will be returned.</param>
/// <param name="parentsOnly">If true, only the outermost matching parents will be returned.</param>
/// <returns></returns>
public static List<T> GetControlsOfType<T>(Control parent, bool childrenOnly, bool parentsOnly) where T : Control
{
	if (parent == null) return null;
	if (childrenOnly && parentsOnly) throw
		new ArgumentException("Only one of childrenOnly and parentsOnly may be true. They are mutually exclusive");

	//We are doing last-minute initialization to minimize the overhead of building one of these.
	//The List<> constructor should only be called n times, where n is the number of ContentPlaceHolder controls.
	List<T> temp = null;

	if (parent.Controls != null)
	{
		//Loop through all of the child controls
		foreach (Control child in parent.Controls)
		{
			//Recursively search them also.
			List<T> next = GetControlsOfType<T>(child,childrenOnly,parentsOnly);

			//To save on initialization costs.
			if (next != null)
			{
				if (temp == null)
				{
					temp = next; //Use existing collection from recursive call
				}
				else
				{
					//Merge the collections

					//If a the same object is the child of two different parents, this will
					//stop it.
					foreach (T c in next)
					{
						if (!temp.Contains(c)) temp.Add(c);
					}

				}
			}
		}
	}

	//If this item is of the target type, add it
	if ((parent is T))
	{
		//If there are no children or we are trying to discard children
		if (parentsOnly || temp == null)
		{
			//Clear the list and add the parent
			T item = (T)parent;

			temp = new List<T>();

			temp.Add(item);
		}
		else if (!childrenOnly)
		{
			//Append the parent with the children
			T item = (T)parent;

			if (temp == null) temp = new List<T>();

			temp.Add(item);
		}
	}

	return temp;
}

The remainder of the PageBase class

/// 

/// Extends System.Web.UI.Page
/// Adds metadata and stylehseet management
/// 
public partial class PageBase : Page
{

/// <summary>
/// Creates a new PageBase instance.
/// </summary>
public PageBase()
{
}

protected MetadataManager _metadata = null;
/// <summary>
/// Manages page metadata. Add, remove, and query metadata
/// (Only meta tags with a name attribute are affected, and only those located in the head section)
/// </summary>
public MetadataManager Metadata {
	get {
		if (_metadata == null) _metadata = new MetadataManager(this);
		return _metadata;
	}
}

protected LinkManager _Stylesheets = null;
/// <summary>
/// Manages all of the HtmlLink controls in the head section of the page.
/// Register, delete, and enumerate all link tags.
/// </summary>
public LinkManager Stylesheets
{
	get
	{
		if (_Stylesheets == null) _Stylesheets = new LinkManager(this);
		return _Stylesheets;
	}
}

LinkManager

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Text.RegularExpressions;
using System.Collections.Specialized;

namespace fbs
{
    public partial class PageBase
    {
        /// <summary>
        /// Manages &lt;link> tags (controls) on the current page.
        /// </summary>
        public class LinkManager
        {
            protected Page _page = null;
            /// <summary>
            /// Creates a new Link Manager attached to the specified Page instance
            /// </summary>
            /// <param name="parent"></param>
            public LinkManager(Page parent)
            {
                _page = parent;
            }
            /// <summary>
            /// Adds a CSS reference. Paths must be 1) relative to the page, 2) application-relative, or 3) absolute
            /// </summary>
            /// <param name="href"></param>
            public void AddLink(string href)
            {
                AddLink(href, "stylesheet", "text/css");
            }
            /// <summary>
            /// Adds a CSS stylsheet reference, but only if there isn't one yet for that path.
            /// Paths must be 1) relative to the page, 2) application-relative, or 3) absolute
            /// </summary>
            /// <param name="href"></param>
            /// <param name="resolveFirst">If true, compares resolved paths instead of raw paths</param>
            public void AddLinkIfMissing(string href)
            {
                if (this.FindLinkControl(href) == null)
                {
                    AddLink(href);
                }
            }
            /// <summary>
            /// Adds a link tag with the specified rel and type attributes
            /// Paths must be 1) relative to the page, 2) application-relative, or 3) absolute
            /// </summary>
            /// <param name="href"></param>
            /// <param name="rel"></param>
            /// <param name="type"></param>
            public void AddLink(string href, string rel, string type)
            {
                HtmlLink l = new HtmlLink();

                l.EnableViewState = false;
                l.Href = href;
                l.Attributes["type"] = type;
                l.Attributes["rel"] = rel;
                l.AppRelativeTemplateSourceDirectory = _page.AppRelativeTemplateSourceDirectory;
                _page.Header.Controls.Add(l);
            }
            /// <summary>
            /// Removes all meta tags with a matching href.
            /// Paths must be 1) relative to the page, 2) application-relative, or 3) absolute
            /// </summary>
            /// <param name="href"></param>
            /// <param name="resolveFirst">If true, compares resolved paths instead of raw paths</param>
            public void RemoveLinks(string href)
            {
                bool resolveFirst = false;
                List<HtmlLink> controls = GetControls();
                string searchfor = href;
                if (resolveFirst) searchfor = _page.ResolveUrl(searchfor);
                foreach (HtmlLink hl in controls)
                {
                    string thishref = hl.Href;

                    if (resolveFirst) thishref = _page.ResolveUrl(thishref);

                    if (thishref.Equals(searchfor, StringComparison.OrdinalIgnoreCase))
                    {
                        hl.Parent.Controls.Remove(hl);
                    }
                }

            }
            /// <summary>
            /// Returns a collection of all HtmlLink controls in the page header.
            /// </summary>
            /// <returns></returns>
            public List<HtmlLink> GetControls()
            {
                return PageBase.GetControlsOfType<HtmlLink>(_page.Header);
            }
            /// <summary>
            /// Returns a collection of the hrefs in each link tag in the head section.
            /// Paths are 1) relative to the page, 2) application-relative, or 3) absolute
            /// </summary>
            /// <returns></returns>
            public List<string> GetHrefs()
            {
                List<HtmlLink> list = GetControls();
                List<string> hrefs = new List<string>();
                foreach (HtmlLink l in list)
                {
                    hrefs.Add(l.Href);
                }
                return hrefs;
            }
            /// <summary>
            /// Case-insensitive. Returns the first HtmlLink control in the heirarchy that matches the href. Only scans inside the head tag.
            /// returns null if no match is found.
            ///
            /// </summary>
            /// <param name="href">Paths must be 1) relative to the page, 2) application-relative, or 3) absolute</param>
            /// <param name="resolveFirst">If true, compares resolved paths instead of raw paths</param>
            /// <returns></returns>
            public HtmlLink FindLinkControl(string href)
            {
                bool resolveFirst = false;
                List<HtmlLink> controls = GetControls();
                string searchfor = href;
                if (resolveFirst) searchfor = _page.ResolveUrl(searchfor);
                foreach (HtmlLink hl in controls)
                {
                    string thishref = hl.Href;

                    if (resolveFirst) thishref = _page.ResolveUrl(thishref);

                    if (thishref.Equals(searchfor, StringComparison.OrdinalIgnoreCase)) return hl;
                }
                return null;
            }

        }
    }
}

MetadataManager

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Text.RegularExpressions;
using System.Collections.Specialized;

namespace fbs
{
    public partial class PageBase
    {
        /// <summary>
        /// Manages &lt;meta> tags (controls) on the current page. Not designed for HTTP-EQUIV tags - they are ignored and skipped unless they have a name attribute.
        /// Only deals with meta tags within the Head of the page. The page must have a server-side head tag.
        /// </summary>
        public class MetadataManager
        {
            protected Page _page = null;

            /// <summary>
            /// Creates a new MetadataManager and attaches it to the current page.
            /// </summary>
            /// <param name="parent"></param>

            public MetadataManager(Page parent)
            {
                _page = parent;
            }
            /// <summary>
            /// Gets or sets the Content attribute for the specified metadata tag.
            /// Returns null if pair does not exist.
            /// Creates a new metadata tag if it does not exist.
            /// </summary>
            /// <param name="name"></param>
            /// <returns></returns>
            public string this[string name]
            {

                get
                {
                    HtmlMeta m = FindMetaControl(name, _page.Header);
                    if (m == null) return null;
                    return m.Content;
                }
                set
                {
                    HtmlMeta m = FindMetaControl(name, _page.Header);
                    if (m != null)
                    {
                        m.Content = value;
                    }
                    else
                    {
                        HtmlMeta newm = new HtmlMeta();
                        newm.EnableViewState = false;
                        newm.Name = name;
                        newm.Content = value;
                        _page.Header.Controls.Add(newm);
                    }

                }

            }
            /// <summary>
            /// Returns a collection of all HtmlMeta controls in the header
            /// </summary>
            /// <returns></returns>
            public List<HtmlMeta> GetControls()
            {
                return PageBase.GetControlsOfType<HtmlMeta>(_page.Header);
            }
            /// <summary>
            /// Returns a name:value collection of meta name:content pairs from the page.
            /// If there are multiple meta tags with the same name, the contents are comma-delimited (NameValueCollection.Add behavior)
            /// </summary>
            /// <returns></returns>
            public NameValueCollection GetNameContentPairs()
            {
                List<HtmlMeta> list = PageBase.GetControlsOfType<HtmlMeta>(_page.Header);
                NameValueCollection pairs = new NameValueCollection();
                foreach (HtmlMeta m in list)
                {
                    pairs.Add(m.Name, m.Content);
                }
                return pairs;
            }
            /// <summary>
            /// Returns the first HtmlMeta control with the specified name
            /// </summary>
            /// <param name="name"></param>
            /// <returns></returns>
            public HtmlMeta GetControl(string name)
            {
                return FindMetaControl(name, this._page.Header);
            }
            /// <summary>
            /// Whether to include or exclude matches
            /// </summary>
            public enum FilterType
            {
                ReturnMatches = 1,
                ReturnNonMatches = 2
            }
            /// <summary>
            /// Returns all meta tags that don't match 'pattern'
            /// To exclude all, specify "*". Otherwise, specify a list of exclusions: "date,expires,description,flags".
            /// Not regex, but case-insensitive.
            /// </summary>
            /// <param name="pattern">To exclude all, specify "*". Otherwise, specify a list of exclusions: "date,expires,description,flags".</param>
            /// <returns></returns>
            public List<HtmlMeta> GetNonMatches(string pattern)
            {
                return GetMatches(pattern, FilterType.ReturnNonMatches);
            }
            /// <summary>
            /// Returns all meta tags with a name that matches 'pattern'
            /// To match all, specify "*". Otherwise, specify a list of possibilities: "date,expires,description,flags".
            /// Not regex, but case-insensitive.
            /// </summary>
            /// <param name="pattern">To match all, specify "*". Otherwise, specify a list of possibilities: "date,expires,description,flags".</param>
            /// <returns></returns>
            public List<HtmlMeta> GetMatches(string pattern)
            {
                return GetMatches(pattern, FilterType.ReturnMatches);
            }

            /// <summary>
            /// Removes the specified HtmlMeta controls from their parents.
            /// </summary>
            /// <param name="list"></param>
            public void RemoveControls(List<HtmlMeta> list)
            {
                foreach (HtmlMeta m in list)
                {
                    if (m.Parent != null)
                    {
                        m.Parent.Controls.Remove(m);
                    }
                }
            }

            /// <summary>
            /// Hides the specified HtmlMeta controls from rendering
            /// </summary>
            /// <param name="list"></param>
            public void HideControls(List<HtmlMeta> list)
            {
                foreach (HtmlMeta m in list)
                {
                    m.Visible = false;
                    m.EnableViewState = false;
                }
            }
            /// <summary>
            /// Returns a collection of HtmlMeta tags that match 'pattern' (or don't match, depending on 'filter').
            /// Pattern is not a regex, but supports alternations and is case-insensitive. if Pattern="*", then everything matches.
            /// Pattern can be a single meta name, or a list of meta names (comma or | delimited).
            /// </summary>
            /// <param name="pattern">To match all, specify "*". Otherwise, specify a list of possibilities: "date,expires,description,flags".</param>
            /// <param name="filter"></param>
            /// <returns></returns>
            public List<HtmlMeta> GetMatches(string pattern, FilterType filter)
            {

                //List of all meta controls in the head
                List<HtmlMeta> list = PageBase.GetControlsOfType<HtmlMeta>(_page.Header);

                //Parse pattern string
                bool wildcard = (pattern.Equals("*", StringComparison.OrdinalIgnoreCase));

                string[] parts = pattern.Replace(',', '|').Split('|');
                for (int i = 0; i < parts.Length; i++)
                    parts[i] = parts[i].Trim().ToLowerInvariant();

                //Index valid names in a binary tree
                List<string> names = new List<string>(parts);
                names.Sort();

                //Create collections to hold matches and non-matches.
                List<HtmlMeta> matches = new List<HtmlMeta>();
                List<HtmlMeta> nonmatches = new List<HtmlMeta>();

                //Loop throught controls and distribute to the appropriate collection.
                foreach (HtmlMeta m in list)
                {
                    //Skip meta tags with an no name (probably HTTP-EQIV)
                    if (m.Name == null) continue;

                    if (wildcard)
                    {
                        matches.Add(m);
                    }
                    else if ((names.BinarySearch(m.Name.ToLowerInvariant()) > 0))
                    {
                        matches.Add(m);
                    }
                    else
                    {
                        nonmatches.Add(m);
                    }
                }

                //Return the correct collection based upon the filter type
                if (filter == FilterType.ReturnMatches) return matches;
                else if (filter == FilterType.ReturnNonMatches) return nonmatches;
                else throw new ArgumentException("filter must be a valid enumeration value", "filter");
            }
            /// <summary>
            /// Recursively searches the hierarchy of 'parent' for the first HtmlMeta instance with the specified Name attribute.
            /// Case-insensitive.
            /// </summary>
            /// <param name="name">Case-insensitive. </param>
            /// <param name="parent">Control tree to search</param>
            /// <returns></returns>
            protected static HtmlMeta FindMetaControl(string name, Control parent)
            {
                if (parent is HtmlMeta)
                {
                    HtmlMeta m = parent as HtmlMeta;
                    if (m.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) return m;
                }
                foreach (Control c in parent.Controls)
                {
                    HtmlMeta m = FindMetaControl(name, c);
                    if (m != null) return m;
                }
                return null;
            }

        }
    }
}

Integrating script support

If you haven’t already read Referencing stylesheets and scripts from content pages, give it a glance. Download the attached code files and combine them with this one. The only file you’ll have to merge is PageBase.cs.

Just add this code to the PageBase.cs included in the article, and make sure ContentPlaceHolderFixes.cs and the ScriptReference.cs files are included also.

/// <summary>
/// Calls the ContentPlaceHolderHeadRepair.Repair method
/// </summary>
/// <param name="e"></param>
protected override void OnLoad(EventArgs e)
{
	//Parses link, meta, and script tags that got missed by the Head>CPH bug.
	ContentPlaceHolderFixes.RepairPageHeader(this);

	//Fire the events later
	base.OnLoad(e);
}

This will allow you to use script tags from the head section and get proper ASP.NET URL resolution on them.

If you have any questions, please use the comments form below.

Happy coding!

Download files

This integration isn’t valuable to most people, however, since they aren’t protecting any static files.
Users who don’t need this protection can enable the “AllowFolderResizeNotation” setting to gain additional URL flexibility in exchange.

Version 1.2 now passes *all* file serving work back to IIS. The cached image is now written to disk first rather than last, allowing a simple RewritePath call to handle the work.

The same code can now be used for both IIS5, 6, 7c and 7i. The httpModules section handles IIS5/6/7c, and the modules section handles IIS7 integrated mode.

<system.web>
  ...
  <httpModules>
    <add name="ImageResizer" type="fbs.ImageResizer.InterceptModule"/>
  </httpModules>
  ...
</system.web>
<system.webServer>
  <validation validateIntegratedModeConfiguration="false"/>
  ...
  <modules>
    <add name="ImageResizer" type="fbs.ImageResizer.InterceptModule"/>
  </modules>
</system.webServer>