MVP Dependency Chaining Framework

using System;
using System.Collections.Generic;
using System.Text;
using System.Web;
using System.Web.Caching;
using System.Reflection;
using System.ComponentModel;

/************************************************************************************
*
* Copyright � 2007 Rohit Gadagkar
*
* This software is provided 'as-is', without any explicit or implied warranty. 
*
* Permission is granted to anyone to use this software for any purpose, including
* commercial applications, and to alter it and redistribute it freely, subject to the
* following restrictions:
*
* 1. The origin of this software must not be misrepresented. You must not claim that
* you wrote the original software. If you use this software in a product, 
* the following acknowledgement in the product documentation is required.
*
* "Portions Copyright � 2007 Rohit Gadagkar"
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
************************************************************************************/

namespace MVPChainingFactory.Caching.Web
{
    public class WebCacheItemManager<T> : ICacheItemManager<T> where T:class
    {
        EventHandlerList _events;
        string _cacheDependencyAssembly;
        static object _eventKey;
        string _cacheItemKey;
        
        public WebCacheItemManager(string cacheItemKey)
        {
            _eventKey = new object();
            _events = new EventHandlerList();
            _cacheItemKey = cacheItemKey;
        }

        private WebCacheItemManager() { }

        #region ICacheItemManager<T> Members

        public T Get()
        {
            return HttpRuntime.Cache[GetCacheKey()] as T;
        }

        public void Put(T item)
        {
            string key = GetCacheKey();
            Cache c = HttpRuntime.Cache;
            Assembly a = Assembly.Load(CacheDependencyAssembly);
            CacheDependency dep = a != null ? new CacheDependency(a.Location) : null;            
            // if cache item is already present calling Cache.Insert will invoke the 
            // CacheItemRemovedCallback and this will produce an infinite recursion
            if (c[key] == null)
            {
                c.Insert(key,
                    item,
                    dep,
                    Cache.NoAbsoluteExpiration,
                    Cache.NoSlidingExpiration,
                    CacheItemPriority.Default,
                    delegate(string k, object v, CacheItemRemovedReason reason)
                    {
                        CacheInvalidatedEventHandler<T> e = _events[_eventKey] as
                            CacheInvalidatedEventHandler<T>;
                        T value = v as T;
                        if (e != null)
                            e(k, value);
                    }
                );
            }
        }

        public string GetCacheKey()
        {
            return _cacheItemKey;
        }

        public string CacheDependencyAssembly 
        { 
            get { return _cacheDependencyAssembly; }
            set { _cacheDependencyAssembly = value; }
        }

        public event CacheInvalidatedEventHandler<T> CacheInvalidated
        {
            add { _events.AddHandler(_eventKey, value); }
            remove { _events.RemoveHandler(_eventKey, value); }
        }

        #endregion
    }
}