Question

We are refactoring our site to use an external cache and the first step we took was using a custom OutputCacheProvider. First, we created a simple provider that just wraps MemoryCache and found problems with the way we are managing dependencies.

We have a custom OutputCacheAttribute that adds an extra key dependency to be able to invalidate a set of pages when certain entities change and to keep this feature I see some options:

1. Removing manually the CachedVary that ASP.NET stores in the cache, assuming that the key is "a2" + query". This seems to work but I’m not sure about the reliability.

2. Add cache keys that contain an array of the pages that have to be evicted from the cache then the key is removed o use the external cache key dependency feature in case it has it. This should be enough to emulate the key dependency we used but in a more complex way.

3. Forget about this, put a short cache period and let them expire without worrying much about that.

4. Do our own page caching and forget about ASP.NET output cache, not very appealing.

I’m sure there are other ways. Any tips, experiences or recommendations?

Answer 1

I answer my own question with the solution we adopted just for the record.

In our OutputCacheAttribute we add an empty cache object with a key that depends on the requested URL and some parameters. This will be used to invalidate a page externally.

Then, we also add another object with a key that depends on the current request and contains the previous cacheKey.

Finally, a static ValidationCallback is set up. The callback gets the value of the key for the current request, which is the dependency key. Then if it’s not null, gets the value of the dependency, if it’s null, the dependency has been evicted and we set the validationStatus to HttpValidationStatus.Invalid.

Some code to illustrate:

public override void OnResultExecuting(ResultExecutingContext filterContext)
{
    base.OnResultExecuting(filterContext);

    // Build dependencies
    BuildDependencies(paramsToDepend, filterContext.Controller, this.Duration);
}

private void BuildDependencies(IEnumerable<string> paramsToDepend, ControllerBase controller, int duration)
{
    string[] valuesToInclude = GetValuesToInclude(paramsToInclude, controller.ControllerContext);

    // Build the caché key for the current request
    var cacheKey = CacheKeyProvider.GetCacheKeyFor(controller, paramsToDepend);

    var cache = controller.ControllerContext.HttpContext.Cache;
    var cacheValue = cache.Get(cacheKey);

    if (cacheValue == null)
    {
        // The key is created if not exists
        Provider.Add(cacheKey, new object(), Context.CurrentDateTime.AddSeconds(duration).ToUniversalTime());
    }

    // Add the dependency
    Provider.Set(CachePrefix + controller.ControllerContext.HttpContext.Request.Path, cacheKey, Context.CurrentDateTime.AddSeconds(duration).ToUniversalTime());

    // Register callback
    controller.ControllerContext.HttpContext.Response.Cache.AddValidationCallback(new HttpCacheValidateHandler(ValidationCallback), null);
}

public static void ValidationCallback(HttpContext context, object data, ref HttpValidationStatus validationStatus)
{
    var provider = OutputCache.Providers[OutputCache.DefaultProviderName];

    var dependency = provider.Get(CachePrefix + context.Request.RawUrl) as string;

    if (dependency == null) return;

    var depValue = provider.Get(dependency);

    // If it's null, someone has invelidated the caché (an entity was modified)
    if (depValue == null)
    {
        validationStatus = HttpValidationStatus.Invalid;
    }
}