CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 20:05:05 GMT

Current revision posted to Articoli by ilNero on 08/04/2010 22:05:05

CSS e Javascript minification con ASP.NET

Chiunque abbia a che fare con la programmazione web si sarà reso conto che l'utilizzo dei CSS, così come l'utilizzo di framework javascript come jQuery, sia ormai praticamente uno standard de-facto.
Per quanto riguarda i framework Javascript, questi vengono rilasciati costantemente sia in versione 'sources' che in versione 'minified', lasciando però la scelta del minifier da utilizzare esclusivamente ai creatori/mantainer del framework.
Purtroppo ho la smania di tenere costantemente tutto sotto controllo, ragion per cui negli ultimi mesi ho cominciato a studiare i vari software che operano la minification.
Sul web se ne trovano diversi:

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

Dopo diversi test e diverse rilasci in produzione di fogli di stile e codice javascript minimizzato con questo tool, posso affermare di non aver mai riscontrato incompatibilità o problemi di sorta.
L'unico grande difetto di questo tool è il suo essere un tool da riga di comando, il che si traduce in una serie di step da eseguire in pre-produzione.
Se da un lato, le modifiche a queste tipologie di file, sono rare, una volta raggiunta la fase di rilascio, è pur vero che piccole migliorie vengono sempre apportate dopo il rilascio di una applicazione web.
Stanco quindi di aprire frequentemente il prompt dei comandi, ho cercato una soluzione da inglobare direttamente nei progetti web, che riuscisse a minimizzare on-the-fly i CSS e i JS.

Animato dall'esigenza e dalla scoperta di questo porting per .NET YUI Compresso for .NET, ho buttato giù questo semplice HttpHandler, capace di riconoscere le richieste giuste e rispondere con la versione minimizzata del file richiesto.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

L'handler va ovviamente mappato nel web.config. Devo però fornire una doverosa annotazione: nel mio caso ho mappato le estensioni *.js.axd e *.css.axd. Questa scelta mi obbliga a dover fare attenzione nelle pagine .aspx o .html che creo, in quanto i riferimenti ai fogli di stile ed ai file javascript devono finire con questa estensione per essere processati. In un contesto di hosting condiviso (leggi Aruba), dove non ho possibilità di intervento sulle estensioni mappate in IIS, questa mi sembrava la scelta migliore. In contesti di maggior libertà di mapping delle estensioni in IIS, sarebbe bastato mappare le estensioni .css e .js sull'engine di ASP.NET, e mappare le stesse estensioni sull'handler.

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 20:04:27 GMT

Revision 9 posted to Articoli by ilNero on 08/04/2010 22:04:27

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 20:02:31 GMT

Revision 8 posted to Articoli by ilNero on 08/04/2010 22:02:31

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 19:56:44 GMT

Revision 7 posted to Articoli by ilNero on 08/04/2010 21:56:44

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 18:35:09 GMT

Revision 6 posted to Articoli by ilNero on 08/04/2010 20:35:09

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi , mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 11:03:02 GMT

Revision 5 posted to Articoli by ilNero on 08/04/2010 13:03:02

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 11:02:08 GMT

Revision 4 posted to Articoli by ilNero on 08/04/2010 13:02:08

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 11:01:46 GMT

Revision 3 posted to Articoli by ilNero on 08/04/2010 13:01:46

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 10:57:56 GMT

Revision 2 posted to Articoli by ilNero on 08/04/2010 12:57:56

CSS e Javascript minification con ASP.NET

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using Yahoo.Yui.Compressor;

namespace DotNetCampania.Web.Handlers
{
	public class YUICompressor : IHttpHandler
	{
		private const int DEFAULT_CACHE_DURATION = 1440;
		private bool useCache = true;
		private bool noCompression = false;

		public bool IsReusable { get { return true; } }
		
		public void ProcessRequest(HttpContext context)
		{
			bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
			bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
			context.Response.ContentType = "text/plain";
			string filePath = GetFilePath();
			string fileExtension = Path.GetExtension(filePath);
			if (File.Exists(filePath))
			{
				context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
				switch (fileExtension)
				{
					case ".css":
						context.Response.ContentType = "text/css";
						if (!this.noCompression) 
							CompressCSS(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					case ".js" :
						context.Response.ContentType = "application/x-javascript";
						if (!this.noCompression)
							CompressJavaScript(filePath);
						else
							HttpContext.Current.Response.WriteFile(filePath);
						break;
					default :
						context.Response.StatusCode = 404;
						break;
				}
			}
			else
			{
				context.Response.StatusCode = 404;
			}
			context.Response.Flush();
			context.Response.End();
		}
		
		private string GetFilePath()
		{
			string filePath = HttpContext.Current.Request.Url.AbsolutePath;
			filePath = filePath.TrimEnd(".axd".ToCharArray());
			filePath = HttpContext.Current.Server.MapPath(filePath);
			return filePath;
		}

		private void CompressCSS(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = CssCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}

		private void CompressJavaScript(string filePath)
		{
			if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
			{
				HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
				return;
			}
			object fileLock = new object();
			lock (fileLock)
			{
				StreamReader sr = new StreamReader(filePath, true);
				string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
				HttpContext.Current.Response.Write(compressed);
				if (this.useCache)
					HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
				sr.Close();
			}
		}
	}
}

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)

CSS e Javascript minification con ASP.NET

ilNero — Thu, 08 Apr 2010 10:57:01 GMT

Revision 1 posted to Articoli by ilNero on 08/04/2010 12:57:01

Su tutti, la mia attenzione si è focalizzata molto su YUI Compressor, che a detta dei suoi sviluppatori

The YUI Compressor is JavaScript minifier designed to be 100% safe and yield a higher compression ratio than most other tools.

        using System;
        using System.Collections.Generic;
        using System.IO;
        using System.Linq;
        using System.Text;
        using System.Web;
        using Yahoo.Yui.Compressor;

        namespace DotNetCampania.Web.Handlers
        {
            public class YUICompressor : IHttpHandler
            {
                private const int DEFAULT_CACHE_DURATION = 1440;
                private bool useCache = true;
                private bool noCompression = false;

                public bool IsReusable { get { return true; } }
                
                public void ProcessRequest(HttpContext context)
                {
                    bool.TryParse(context.Request.QueryString.Get("useCache"), out this.useCache);
                    bool.TryParse(context.Request.QueryString.Get("noCompression"), out this.noCompression);
                    context.Response.ContentType = "text/plain";
                    string filePath = GetFilePath();
                    string fileExtension = Path.GetExtension(filePath);
                    if (File.Exists(filePath))
                    {
                        context.Response.AddHeader("Content-Disposition", "filename=" + Path.GetFileName(filePath));
                        switch (fileExtension)
                        {
                            case ".css":
                                context.Response.ContentType = "text/css";
                                if (!this.noCompression) 
                                    CompressCSS(filePath);
                                else
                                    HttpContext.Current.Response.WriteFile(filePath);
                                break;
                            case ".js" :
                                context.Response.ContentType = "application/x-javascript";
                                if (!this.noCompression)
                                    CompressJavaScript(filePath);
                                else
                                    HttpContext.Current.Response.WriteFile(filePath);
                                break;
                            default :
                                context.Response.StatusCode = 404;
                                break;
                        }
                    }
                    else
                    {
                        context.Response.StatusCode = 404;
                    }
                    context.Response.Flush();
                    context.Response.End();
                }
                
                private string GetFilePath()
                {
                    string filePath = HttpContext.Current.Request.Url.AbsolutePath;
                    filePath = filePath.TrimEnd(".axd".ToCharArray());
                    filePath = HttpContext.Current.Server.MapPath(filePath);
                    return filePath;
                }

                private void CompressCSS(string filePath)
                {
                    if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
                    {
                        HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
                        return;
                    }
                    object fileLock = new object();
                    lock (fileLock)
                    {
                        StreamReader sr = new StreamReader(filePath, true);
                        string compressed = CssCompressor.Compress(sr.ReadToEnd());
                        HttpContext.Current.Response.Write(compressed);
                        if (this.useCache)
                            HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
                        sr.Close();
                    }
                }

                private void CompressJavaScript(string filePath)
                {
                    if (this.useCache & HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()] != null)
                    {
                        HttpContext.Current.Response.Write((string)HttpContext.Current.Cache[HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString()]);
                        return;
                    }
                    object fileLock = new object();
                    lock (fileLock)
                    {
                        StreamReader sr = new StreamReader(filePath, true);
                        string compressed = JavaScriptCompressor.Compress(sr.ReadToEnd());
                        HttpContext.Current.Response.Write(compressed);
                        if (this.useCache)
                            HttpContext.Current.Cache.Add(HttpContext.Current.Request.Url.AbsolutePath.GetHashCode().ToString(), compressed, null, DateTime.MaxValue, new TimeSpan(0, DEFAULT_CACHE_DURATION, 0), System.Web.Caching.CacheItemPriority.Normal, null);
                        sr.Close();
                    }
                }
            }
        }

Come si evince dal codice, l'handler utilizza anche la cache in modo da evitare di processare i singoli file ad ogni richiesta, ma solo quando strettamente necessario.

Una ulteriore aggiunta potrebbe essere l'utilizzo di chiavi negli appSettings, in modo da controllare l'abilitazione globale dell'handler direttamente da web.config, ma lo lascio fare a voi, mentre mi godo il fresco di questo temporalone estivo :)