The purpose of the unit test is to check if the logger logs a message or not, depending on the level of the threshold configured. It should also write exception messages when given.  The idea is to use Log4Net MemoryAppender and test the output.

Here is the code (I am using Shouldy for assertion), use it at will:

public interface ILogManager
{
 void Debug(string message, Exception ex = null);
 void Info(string message, Exception ex = null);
 void Warn(string message, Exception ex = null);
 void Error(string message, Exception ex = null);
 void Fatal(string message, Exception ex = null);
}

public class LogManager : ILogManager
{
 private readonly ILog _logger;
 private bool _isDebugEnabled;
 private bool _isInfoEnabled;
 private bool _isWarnEnabled;
 private bool _isErrorEnabled;
 private bool _isFatalEnabled;

public LogManager()
 {
 _logger = log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 XmlConfigurator.Configure();
 SetLoggingLevelConstants();
 }

public LogManager(ILog logger)
 {
 _logger = logger;
 SetLoggingLevelConstants();
 }

public void Debug(string message, Exception ex = null)
 {
 Log(_isDebugEnabled, _logger.Debug, message, ex);
 }

public void Info(string message, Exception ex = null)
 {
 Log(_isInfoEnabled, _logger.Info, message, ex);
 }

public void Warn(string message, Exception ex = null)
 {
 Log(_isWarnEnabled, _logger.Warn, message, ex);
 }

public void Error(string message, Exception ex = null)
 {
 Log(_isErrorEnabled, _logger.Error, message, ex);
 }

public void Fatal(string message, Exception ex = null)
 {
 Log(_isFatalEnabled, _logger.Fatal, message, ex);
 }

private void SetLoggingLevelConstants()
 {
 _isDebugEnabled = _logger.IsDebugEnabled;
 _isInfoEnabled = _logger.IsInfoEnabled;
 _isWarnEnabled = _logger.IsWarnEnabled;
 _isErrorEnabled = _logger.IsErrorEnabled;
 _isFatalEnabled = _logger.IsFatalEnabled;
 }

private static void Log(bool enabled, Action<string, Exception> logAction, string message, Exception exception = null)
 {
 if (!enabled)
 return;
 logAction(message, exception);
 }
}

[TestClass]
public class LogManagerShould
{
 private MemoryAppender _appender;
 private const string LOG_MESSAGE = "test message";
 private readonly Exception _exception = new Exception("test exception");

[TestMethod]
 public void LogDebugMessagesWhenDebugEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Debug);

//act
 logManager.Debug(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 }

[TestMethod]
 public void LogDebugMessagesWithExceptionWhenDebugEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Debug);

//act
 logManager.Debug(LOG_MESSAGE, _exception);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 GetLogException().ShouldBe(GetLogExceptionMessage());
 }

[TestMethod]
 public void NotLogDebugMessagesWhenDebugDisabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Info);

//act
 logManager.Debug(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(null);
 }

[TestMethod]
 public void LogInfoMessagesWhenInfoEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Info);

//act
 logManager.Info(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 }

[TestMethod]
 public void LogInfoMessagesWithExceptionWhenInfoEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Info);

//act
 logManager.Info(LOG_MESSAGE, _exception);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 GetLogException().ShouldBe(GetLogExceptionMessage());
 }

[TestMethod]
 public void NotLogInfoMessagesWhenInfoDisabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Warn);

//act
 logManager.Info(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(null);
 }

[TestMethod]
 public void LogWarnMessagesWhenWarnEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Warn);

//act
 logManager.Warn(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 }

[TestMethod]
 public void LogWarnMessagesWithExceptionWhenWarnEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Warn);

//act
 logManager.Warn(LOG_MESSAGE, _exception);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 GetLogException().ShouldBe(GetLogExceptionMessage());
 }

[TestMethod]
 public void NotLogWarnMessagesWhenWarnDisabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Error);

//act
 logManager.Warn(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(null);
 }

[TestMethod]
 public void LogErrorMessagesWhenErrorEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Error);

//act
 logManager.Error(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 }

[TestMethod]
 public void LogErrorMessagesWithExceptionWhenErrorEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Error);

//act
 logManager.Error(LOG_MESSAGE, _exception);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 GetLogException().ShouldBe(GetLogExceptionMessage());
 }

[TestMethod]
 public void NotLogErrorMessagesWhenErrorDisabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Fatal);

//act
 logManager.Error(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(null);
 }

[TestMethod]
 public void LogFatalMessagesWhenFatalEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Fatal);

//act
 logManager.Fatal(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 }

[TestMethod]
 public void LogFatalMessagesWithExceptionWhenFatalEnabled()
 {
 //arrange
 var logManager = GetLogManager(Level.Fatal);

//act
 logManager.Fatal(LOG_MESSAGE, _exception);

//assert
 GetLogMessage().ShouldBe(LOG_MESSAGE);
 GetLogException().ShouldBe(GetLogExceptionMessage());
 }

[TestMethod]
 public void NotLogFatalMessagesWhenOff()
 {
 //arrange
 var logManager = GetLogManager(Level.Off);

//act
 logManager.Fatal(LOG_MESSAGE);

//assert
 GetLogMessage().ShouldBe(null);
 }

private ILogManager GetLogManager(Level level)
 {
 _appender = new MemoryAppender
 {
 Name = "Unit Testing Appender",
 Layout = new log4net.Layout.PatternLayout("%message"),
 Threshold = level
 };
 _appender.ActivateOptions();

var root = ((Hierarchy)log4net.LogManager.GetRepository()).Root;
 root.AddAppender(_appender);
 root.Repository.Configured = true;

var rootLogger = log4net.LogManager.GetLogger("root");
 return new LogManager(rootLogger);
 }

private string GetLogMessage()
 {
 if (_appender.GetEvents().Length == 0)
 return null;
 var logEvent = _appender.GetEvents()[0];
 return logEvent.MessageObject.ToString();
 }

private string GetLogException()
 {
 if (_appender.GetEvents().Length == 0)
 return null;
 var logEvent = _appender.GetEvents()[0];
 return logEvent.ExceptionObject.ToString();
 }

private string GetLogExceptionMessage()
 {
 return string.Format("{0}: {1}", _exception.GetType().FullName, _exception.Message);
 }
}

Happy coding!

My role of thumb for this kind of infrastructure is that the code should be easy to use, flexible enough for many different cases, and relays on a default behavior that can be overridden when needed.

Now lets think about a process of this kind:

The Single Step

1. A process is created from small steps, each one is responsible for a single task.
2. Each step should get the necessary input data and manipulate it.
3. Each step should know how to execute its task. (Daa..)
4. Each task should have the knowledge  how to rollback this task.
5. Each step should be able to make several retry attempts for the execution and rollback.
6. Each step should report if the action was successful or failed.

public enum eStatus
{
 Pending,
 Success,
 Error
}

public abstract class BaseStep
{
 public virtual int ExecuteAttempts { get { return 1; } }
 public virtual int RollbackAttempts { get { return 1; } }

 public abstract eStatus Execute();
 public virtual eStatus Retry()
 {
  return Execute();
 }
 public virtual eStatus Rollback()
 {
  return eStatus.Success;
 }
 public virtual eStatus RetryRollback()
 {
  return Rollback();
 }
}

public interface IProcessManager
{
 eStatus Process();
}

public abstract class BaseProcessManager : IProcessManager
{
	private eStatus _currentStatus;
	private int _currentStep;
	private Func<eStatus> _action;
	protected List<BaseStep> _steps;

	protected BaseProcessManager()
	{
		_currentStatus = eStatus.Pending;
		_steps = new List<BaseStep>();
		Setup();
	}

	protected abstract void Setup();

	public virtual eStatus Process()
	{
		do
		{
			_action = _steps[_currentStep].Execute;
			Run();
			_action = _steps[_currentStep].Retry;
			Retry(_steps[_currentStep].ExecuteAttempts);

			_currentStep++;

		} while (_currentStatus != eStatus.Error && _currentStep < _steps.Count);

		if (_currentStatus == eStatus.Success)
			return eStatus.Success;

		do
		{
			_currentStep--;

			_action = _steps[_currentStep].Rollback;
			Run();
			_action = _steps[_currentStep].RetryRollback;
			Retry(_steps[_currentStep].RollbackAttempts);

		} while (_currentStep > 0);

		return eStatus.Error;
	}

	private void Run()
	{
		_currentStatus = eStatus.Pending;
		_currentStatus = _action.Invoke();
	}

	private void Retry(int numberOfAttempts)
	{
		int attempt = 1;
		while (_currentStatus == eStatus.Error && attempt < numberOfAttempts)
		{
			_currentStatus = _action.Invoke();
			attempt++;
		}
	}
}

That was a bit dramatic… but I will try to demonstrate my point, but first, a small declaration: inheritance is a good way for keeping your code nice and tidy, but if you use it the wrong way, you get a headache.

Lets say we run a bakery. Currently we are creating only 3 products: bread, rolls and cakes.  Each product is created in 3 stages: make dough, bake and wrap. It is pretty straightforwardness to build the object hierarchy for the bakery:

• Create an interface for the product (IProduct)
• Implement 3 products (bread, roll, cake)
• Create a base class for the Factories (ProductFactory)
• Each product factory uses a template method for running the process (create dough, bake, wrap)
• Implement 3 factories, one for each product

Plain and simple. Now we can create a collection of factories, tell them to process and collect the products.

Suddenly we discover that there are 2 types of dough: sweet and salty. We think: “hey, why not create 2 abstract factories, one for sweet and one for salty”. That’s a good idea, and you fill you showed the world your supreme c# kong fu with the Abstract Factory pattern. Yes, you did it again! (and apparently, this is a good design decision).

Now your code structure looks like this:

Your bakery grows, and so is your code.Now you are supporting 20 products, each of them has its own factory, and you are repeating this process of uniting similar factories to more abstract classes that overrides a part of the process.

Now lets fast forward to a more ambitious bakery, one that produce 100,000 different products. The inheritance tree is so big and complex, and so is maintainability: almost any change is breaking something, each new product you add is just a big pain: you don’t remember which factory to use, you do your best, but the odds are against you..

Why does it happens? its is not because inheritance is evil. Actually, inheritance is good, and it will allow us to find the solution, but you are using it the wrong way. The problem is that each factory is tide to these 3 actions. Take 2 factories where 2 actions are the same and one is different – the classic inheritance will call for another base class that implements the 2 methods, and the 2 classes will implement the third. It is time for a different approach, more single responsibility principle one:

Assume each stage is a class of its own, managing only one granular action, for example “Bake()”: We will have the interface IBake, and we will derive classes from it, implementing different baking actions. The same goes with “make dough” and “wrap”. Now, each factory will instantiate the relevant actions, creating all its parts (instantiating dough maker, baker and wrapper) and call them:

What are we gaining here? We gain the ability to create new factories with new combinations of the basic actions. We can also create new dough makers/bakers/wrappers without breaking the existing code. In other words, we are implementing the open/closed principle, meaning “software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification”. Now scaling is more reasonable.

I added some code that demonstrates this concept, you can grab it here.

Happy coding!

In this post I want to show you how to do it correctly. Generally this is a simple process, but when working in high performance environments, we want to be as efficient as possible with creation and consumption of the service from the client application. The basic idea is that creating the channel factory takes time, but WCF will cache this object in the MRU (see here  for more details) and the next invocations will be faster.

A good infrastructure should expose a simple interface, and hide all the “dirty” processes, living the programmer a light and simple access. This is what to “ProxyHelper” class does in this process.

First, we need a service:

[ServiceContract]
public interface ITestService
{
 [OperationContract]
 string DoWork();
}

public class TestService : ITestService
{
 public string DoWork()
 {
   return "Hello";
 }
}

Than we create the proxy for this service, by implementing ClientBase<T> abstract class and the service contract:

public class TestServiceProxy : ClientBase<ITestService>, ITestService
{
#region Ctor

public TestServiceProxy()
{

}

public TestServiceProxy(string endpointConfigurationName)
 : base(endpointConfigurationName)
{

}

public TestServiceProxy(string endpointConfigurationName, string remoteAddress)
 : base(endpointConfigurationName, remoteAddress)
{

}

public TestServiceProxy(string endpointConfigurationName, EndpointAddress remoteAddress)
 : base(endpointConfigurationName, remoteAddress)
{

}

public TestServiceProxy(Binding binding, EndpointAddress remoteAddress) :
 base(binding, remoteAddress)
{

}

#endregion

#region Methods

public string DoWork()
{
   return base.Channel.DoWork();
}

#endregion
}

In the consuming application we add reference to the service contract and proxy dll.
Now, in order to create the proxy instance efficiently and safely, we need to implement a few things:

1. Wrap the proxy instance in a “using” statement
2. Catch all exception types and abort the operation.

This can be done nicely with a proxy helper that will do all the work for us:

public static class ProxyHelper
{
 public static void InvokeProxyMethod<TProxy>(Action<TProxy> action)
 where TProxy : class, IDisposable, ICommunicationObject
 {
   InvokeMethod<TProxy>(action);
 }

public static void InvokeProxyMethod<TProxy>(string endpointConfigurationName, Action<TProxy> action)
 where TProxy : class, IDisposable, ICommunicationObject
 {
   InvokeMethod<TProxy>(action, endpointConfigurationName);
 }

public static void InvokeProxyMethod<TProxy>(string endpointConfigurationName, string address, Action<TProxy> action)
 where TProxy : class, IDisposable, ICommunicationObject
 {
   InvokeMethod<TProxy>(action, endpointConfigurationName, address);
 }

public static void InvokeProxyMethod<TProxy>(Binding binding, EndpointAddress address, Action<TProxy> action)
 where TProxy : class, IDisposable, ICommunicationObject
 {
   InvokeMethod<TProxy>(action, binding, address);
 }

private static void InvokeMethod<TProxy>(Action<TProxy> action, params object[] args)
 where TProxy : class, IDisposable, ICommunicationObject
 {
 using (var proxy = Resolve<TProxy>(args))
 {
   bool success = false;
   proxy.Open();
   try
   {
     action(proxy);
     success = true;
   }
   catch (CommunicationException ex)
   {
     throw new Exception(string.Format("CommunicationException - Failed to invoke '{0}' proxy", proxy.GetType().Name), ex);
   }
   catch (TimeoutException ex)
   {
     throw new Exception(string.Format("TimeoutException - Failed to invoke '{0}' proxy", proxy.GetType().Name), ex);
   }
   catch (Exception ex)
   {
     throw new Exception(string.Format("GeneralException - Failed to invoke '{0}' proxy", proxy.GetType().Name), ex);
   }
   finally
   {
     if (!success)
     {
       proxy.Abort();
     }
   }
  }
 }

private static T Resolve<T>(params object[] args)
{
   Type resolverType = typeof(T);
   if (resolverType == null)
   {
     throw new Exception(string.Format("type '{0}' does not exits", resolverType));
   }
   try
   {
     return (T)Activator.CreateInstance(resolverType, args);
   }
   catch (Exception ex)
   {
     throw new Exception(string.Format("could not create an instance of type '{0}'", resolverType), ex);
   }
 }
}

The helper class creates an instance of the proxy, utilizing all proxy’s constructors, and enables the consuming class to define an action to be performed on the proxy. It wraps the proxy method invocation with the needed “try catch” options.
A simple usage for this helper is as follows: (this example uses the Binding and EndpointAddress constructor of the ClientBase<T> class, but you can use any other option)

public class TestServiceConsumer
{
  public string DoWork()
  {
    Binding binding = new WSHttpBinding();
    EndpointAddress address = new EndpointAddress("http://192.168.11.78:800/InnerOAuthService.svc");
    string response = string.Empty;
    ProxyHelper.InvokeProxyMethod<TestServiceProxy>(binding, address, (proxy) =>
    {
      response = proxy.DoWork();
     });
    return response;
   }
 }

I updated the code again to reflect Otto’s comment. The main concern was that 2 threads will enter simultaneously to the “publishing” code. The need for an atomic check if the the queue is now publishing can be done using Interlocked. Refer to Otto’s comments for context. Thanks again, Otto!

UPDATE – 26/2/2012

I updated the code to be a little more safe – there was a problem with a private member “_onPublishExecuted” being called twice(see in comments). Thanks Otto!
Lately I was busy creating a new infrastructure for our logging system. I work on OpenBook – a website that gets a lot of traffic and involves with many different business processes. I started logging errors, info data and more with the excellent log4net to files, but has the logs got bigger and longer it became almost impossible  to track it. We also use several IIS servers behind a load – balancer, and the result is a lot of logs on many different servers.

I wanted to create an infrastructure that will be able to have the lowest footprint on the production server, but still be able to log a lot of message to some storage (SQL server, NoSQL server, files..).

The main idea is this:

1. Create a singletone/static queue that will collect all messages
2. Once it has X messages or after X seconds – it flushes all messages to another data store.

Since we are dealing with high performance systems, I couldn’t afford any locks in this mechanism: I saw that the “flush” action locks the queue and all threads that try to insert new messages are frozen. I tried using the “ReaderWriterLockSlim” (see my post here) but it didn’t match – there are far more writes than reads in this process.

I headed over to the new ConcurrentQueue<T> object. This object implements almost a thread-safe lock-free mechanism. It was perfect for me. All I had to do was add the limitations for number of messages or timeout and this was pretty easy.

So this is it:

public abstract class CappedQueue<T> : ConcurrentQueue<T> where T : class
{
	protected int _capLimit;
	protected int _timeLimit;
	protected System.Timers.Timer _timer;
	protected int _onPublishExecuted;
	protected ReaderWriterLockSlim _locker;

	protected CappedQueue()
	{
		var config = (CappedQueueConfigSection)ConfigurationManager.GetSection("cappedQueue");
		Init(config.CapLimit, config.TimeLimitInSeconds);
	}

	protected CappedQueue(int capLimit, int timeLimit)
	{
		Init(capLimit, timeLimit);
	}

	public event Action<List<T>> OnPublish = delegate { };

	public virtual new void Enqueue(T item)
	{
		base.Enqueue(item);
		if (Count >= _capLimit)
		{
			Log4NetLogger.Log(eLogLevel.Debug, string.Format("Cap Limit: {0}", _capLimit));
			Publish();
		}
	}

	private void Init(int capLimit, int timeLimit)
	{
		_capLimit = capLimit;
		_timeLimit = timeLimit;
		_locker = new ReaderWriterLockSlim();
		InitTimer();
	}

	protected virtual void InitTimer()
	{
		_timer = new System.Timers.Timer();
		_timer.AutoReset = false;
		_timer.Interval = _timeLimit * 1000;
		_timer.Elapsed += new ElapsedEventHandler((s, e) =>
		{
			Log4NetLogger.Log(eLogLevel.Debug, string.Format("Time Limit: {0}", _timeLimit));
			Publish();
		});
		_timer.Start();
	}

	protected virtual void Publish()
	{
		Task task = new Task(() =>
		{
			List<T> itemsToLog = new List<T>();
			try
			{
				if (IsPublishing())
					return;

				StartPublishing();

				Log4NetLogger.Log(eLogLevel.Debug, string.Format("Start Dequeue {0} items", Count));
				T item;
				while (TryDequeue(out item))
				{
					itemsToLog.Add(item);
				}
			}
			catch (ThreadAbortException tex)
			{
				Log4NetLogger.Log(eLogLevel.Error, "Dequeue items failed", tex);
			}
			catch (Exception ex)
			{
				Log4NetLogger.Log(eLogLevel.Error, "Dequeue items failed", ex);
			}
			finally
			{
				Log4NetLogger.Log(eLogLevel.Debug, string.Format("Dequeued {0} items", itemsToLog.Count));
				OnPublish(itemsToLog);
				CompletePublishing();
			}
		});
		task.Start();
	}

	private bool IsPublishing()
	{
		return (Interlocked.CompareExchange(ref _onPublishExecuted, 1, 0) > 0);
	}

	private void StartPublishing()
	{
		_timer.Stop();
	}

	private void CompletePublishing()
	{
		_timer.Start();
		Interlocked.Decrement(ref _onPublishExecuted);
	}
}

The CappedQueue gets 2 parametes in its constructor – one for the amount of objects and one for the interval (in seconds).
It also expose a delegate of type Action that is fired asynchronously when one of the limits had been reached.

2 other things to notice:

1. When the “Publish”  is fired, it runs a task asynchronously to avoid the locking.
2. All message in the queue are transferred to a new collection for further actions, and the main queue is free again.

Happy coding :)

One thing that is very important to remember is that you have to make sure the lock (either read or write) should be released after the action completes. The most obvious way is something like this:

var locker = new ReaderWriterLockSlim();
try
{
	locker.EnterReadLock();
}
finally
{
	locker.ExitWriteLock();
}

The problem is to enforce all programmers to do it every time they use the locker. There are some debates about a better syntax for doing so here, here and here. Basically we can solve it by wrapping the locking operation in another object that implements the  IDisposable interface and in the Dispose() method release the lock. The problem here is that there are some cases where The Dispose() method will not be called, as explained here.

A better, and more safe approach is something like this:  think of a read operation as a “getter” function that returns an object, and the write as a “setter” that receives an object, than wrap it up with extension method:

public static class ReadWriteLock
{
	public static T AcquireReadLock<T>(this ReaderWriterLockSlim locker, Func<T> action)
	{
		try
		{
			locker.EnterReadLock();
			return action();
		}
		finally
		{
			locker.ExitReadLock();
		}
	}

	public static void AcquireWriteLock(this ReaderWriterLockSlim locker, Action action)
	{
		try
		{
			locker.EnterWriteLock();
			action();
		}
		finally
		{
			locker.ExitWriteLock();
		}
	}
}

and usage:

var originalCollection = new List<string>{"apple","orange"};

//read
var replicatedData = locker.AcquireReadLock<List<string>>(() => originalCollection);

//write
locker.AcquireWriteLock(() => originalCollection.Add("banana"));

Happy coding :)

public class LegacyURLRoute : RouteBase
{
	public override RouteData GetRouteData(HttpContextBase httpContext)
	{
		var url = httpContext.Request.Url.AbsolutePath;
		if (url.Contains(".aspx") || url.Contains(".ashx"))
		{
			var response = httpContext.Response;
			response.Status = "301 Moved Permanently";
			response.RedirectLocation = "/";
			response.End();
		}
		return null;
	}

	public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
	{
		return null;
	}
}

I tend to place this route at the end of the route table to avoid the unnecessary checks:

RouteTable.Routes.Add(new LegacyURLRoute());

My team is working on a big website – OpenBook, which involve a lot of ajax calls (we are using jQuery as our basic JavaScript lib).  We also used Output cache on our ajax actions and all went pretty smooth, until, for some reasons, we had to disable caching of ajax calls on the client. What we discovered is that out Output Cache was also disabled – and this behavior I wanted to prevent.

The way jQuery disables browser caching is by adding “_=[TIMESTAMP]” on each call’s query string, so every new call as a distinct URL. By doing so it disabled Output Cache on the server as well. Why?

The reason for this is that Output Cache is a very early in the life cycle of the request-response model, before the routing and controller creation. Lets say we have a controller called “TaskController” and an action called “Edit” that receives “ID” as parameter. When requesting the URL “/task/edit/1″ the MVC framework will assign ID with the value “1”. Any other parameters will not be used. If jQuery adds “_=[TIMESTAMP]” to the request, our action will not know about it, but Output Cache will and if you use “VaryByParam” it will not cache anything, since one of the parameters as changed.

Output Cache takes all the request’s parameters and creates a string that is uses as a key identifier for the response output.It caches the response with this key, and once this key is being requested again, it will pull the relevant resource from the cache and return it immediately. This is a good thing because the request will not pass through the MVC cycle and the request will not hit a controller or action.

I wanted to come up with a solution that will ignore the “_” parameter. I also wanted to keep using the cache profiles configuration on the web.config. The result is a mix and match of some code I found here and here with my additions.

The Code

public class ActionOutputCacheAttribute : ActionFilterAttribute
{
	private static readonly OutputCacheSection _cacheConfig = (OutputCacheSection)ConfigurationManager.GetSection("system.web/caching/outputCache");
	private static readonly OutputCacheSettingsSection _cacheConfigSettings = (OutputCacheSettingsSection)ConfigurationManager.GetSection("system.web/caching/outputCacheSettings");
	private OutputCacheProfile _cacheProfile;
	private string _cacheKey;

	public ActionOutputCacheAttribute(string cacheProfileName)
	{
		if (string.IsNullOrWhiteSpace(cacheProfileName))
		{
			throw new ArgumentException("Cache profile is required");
		}

		_cacheProfile = _cacheConfigSettings.OutputCacheProfiles[cacheProfileName];

		if (_cacheProfile == null)
		{
			throw new ArgumentException(string.Format("Caching profile '{0}' was not found", _cacheProfile));
		}
	}

	public override void OnActionExecuting(ActionExecutingContext filterContext)
	{
		if (_cacheConfig.EnableOutputCache && CacheOnServer())
		{
			_cacheKey = GenerateKey(filterContext);
			if (filterContext.HttpContext.Cache[_cacheKey] != null)
			{
				filterContext.Result = (ActionResult)filterContext.HttpContext.Cache[_cacheKey];
			}
		}

		base.OnActionExecuting(filterContext);
	}

	public override void OnActionExecuted(ActionExecutedContext filterContext)
	{
		if (_cacheConfig.EnableOutputCache && CacheOnServer())
		{
			filterContext.HttpContext.Cache.Add(
				_cacheKey,
				filterContext.Result,
				null,
				DateTime.Now.AddSeconds(_cacheProfile.Duration),
				Cache.NoSlidingExpiration,
				CacheItemPriority.Normal,
				null
				);
		}
		base.OnActionExecuted(filterContext);
	}

	public override void OnResultExecuted(ResultExecutedContext filterContext)
	{
		if (_cacheConfig.EnableOutputCache && CacheOnClient())
		{
			HttpCachePolicyBase cache = filterContext.HttpContext.Response.Cache;
			TimeSpan cacheDuration = TimeSpan.FromSeconds(_cacheProfile.Duration);

			cache.SetCacheability(HttpCacheability.Public);
			cache.SetExpires(DateTime.Now.Add(cacheDuration));
			cache.SetMaxAge(cacheDuration);
			cache.AppendCacheExtension("must-revalidate, proxy-revalidate");
		}
		base.OnResultExecuted(filterContext);
	}

	private string GenerateKey(ControllerContext filterContext)
	{
		StringBuilder cacheKey = new StringBuilder();

		cacheKey.Append(filterContext.Controller.GetType().FullName);
		if (filterContext.RouteData.Values.ContainsKey("action"))
		{
			cacheKey.Append("_");
			cacheKey.Append(filterContext.RouteData.Values["action"].ToString());
		}

		if (!string.IsNullOrEmpty(_cacheProfile.VaryByParam))
		{
			var varyByParamCollection = _cacheProfile.VaryByParam.Split(';');
			foreach (KeyValuePair<string, object> pair in filterContext.RouteData.Values)
			{
				if (_cacheProfile.VaryByParam == "*" || varyByParamCollection.Contains(pair.Key))
				{
					cacheKey.Append("_");
					cacheKey.Append(pair.Key);
					cacheKey.Append("=");
					cacheKey.Append(pair.Value.ToString());
				}
			}
		}
		if (!string.IsNullOrEmpty(_cacheProfile.VaryByHeader))
		{
			var varyByHeaderCollection = _cacheProfile.VaryByHeader.Split(';');
			foreach (var header in varyByHeaderCollection)
			{
				cacheKey.AppendFormat("_{0}={1}", header, filterContext.HttpContext.Request.Headers[header]);
			}
		}

		return cacheKey.ToString();
	}

	private bool CacheOnClient()
	{
		return _cacheProfile.Location == OutputCacheLocation.Client ||
			   _cacheProfile.Location == OutputCacheLocation.ServerAndClient ||
			   _cacheProfile.Location == OutputCacheLocation.Any ||
			   (int)_cacheProfile.Location == -1;
	}

	private bool CacheOnServer()
	{
		return _cacheProfile.Location == OutputCacheLocation.Server ||
			   _cacheProfile.Location == OutputCacheLocation.ServerAndClient ||
			   _cacheProfile.Location == OutputCacheLocation.Any ||
			   (int)_cacheProfile.Location == -1;
	}
}

Usage

The Action:

[ActionOutputCache("SomeAction")]
public ActionResult SomeAction(int id)
{
	///do something...
	return View();
}

and configuration:

<caching>
      <outputCache enableOutputCache = "true" />
      <outputCacheSettings>
          <outputCacheProfiles>
	      <add name="SomeAction" duration="60" varyByParam="*" varyByHeader="Accept-Language" location="ServerAndClient"/>
          </outputCacheProfiles>
      </outputCacheSettings>
</caching>

Happy Coding :)

There are many solutions to this problem:

1. Target objects with a constructor that take the source object as parameter
2. A factory method that does it.
3. Just a simple piece of code that does the mapping.

When dealing with large applications where this process occurs many times, I think a generic procedure should take place. I also keep in mind the need to keep these object ready for serialization. So I came up with a simple extension method:

public static TTarget MapTo<TSource, TTarget>(this TSource source, Func<TSource, TTarget> mapper)
   where TSource : class
   where TTarget : class
{
   return mapper.Invoke(source);
}

and usage:

public class Source
{
    public string SourceName { get; set; }
}

public class Target
{
    public string TargetName { get; set; }
}
Source source = new Source()
{
    SourceName = "source"
};

Target target = source.MapTo(x =>
{
new Target() { TargetName = x.SourceName };
});