ASP.NET

Lowest of the Low wrote:

MVP pattern for creating web applications

Lowest of the Low wrote:

If state needs to be recorded I presume its done in the model, if the model classes are in an assembly separate from the actual pages do you still use session or some other form of state management?

Lowest of the Low wrote:

How is UI logic such as "disable this button unless condition is met" handled? is the logic embedded in the view ( or the page code behind), presenter or model.

Lowest of the Low wrote:

MVC is not currently an option for us (new technology...risk...etc, etc)

Lowest of the Low wrote:

I still have other questions like where is validation done?

Lowest of the Low wrote:

And in relation to your comment on injecting state via interface I'm being a bit thick today but how?

// Contract of a cache
interface ICache
{
    void Add(string key, object toCache);
    object Get(string key);
    void Remove(string key);
}

// Session-based cache for live system
class SessionCache: ICache
{
    private HttpSessionState Session
    {
        get
        {
            if (HttpContext.Current != null)
                HttpSessionState.Current.Session;
            return null;
        }
    }

    private bool IsSessionAvailable
    {
        get { return HttpContext.Current != null; }
    }

    public void Add(string key, object toCache)
    {
        if (!IsSessionAvailable) throw new InvalidOperationException("Session cache is only available within an HttpContext.");
        
        Session[key] = toCache;
    }

    public object Get(string key)
    {
        if (!IsSessionAvailable) throw new InvalidOperationException("Session cache is only available within an HttpContext.");

        object item = Session[key];
        return item;
    }

    public void Remove(string key)
    {
        if (!IsSessionAvailable) throw new InvalidOperationException("Session cache is only available within an HttpContext.");

        Session.Remove(key);
    }
}

// Dictionary based cache for unit testing
class DictionaryCache: ICache
{
    private Dictionary<string,> m_cache;

    private Dictionary<string,> Cache
    {
        get 
        {
            if (m_cache == null)
            {
                Interlocked.CompareExchange(ref m_cache, new Dictionary<string,>(), null);
            }
            return m_cache;
        }
    }

    public void Add(string key, object toCache)
    {        
        Cache.Add(key, toCache);
    }

    public object Get(string key)
    {
        object item = Cache[key];
        return item;
    }

    public void Remove(string key)
    {
        Cache.Remove(key);
    }
}

// Facade that acts as a single access point to cache
static class CacheManager
{
    private static ICache s_cache;

    public static ICache CacheInstance
    {
        private get { return s_cache; }
        set { s_cache = value; }
    }


    public void Add(string key, object toCache)
    {
        CacheInstance.Add(key, toCache);
    }

    public object Get(string key)
    {
        return CacheInstance.Get(key);
    }

    public void Remove(string key)
    {
        CacheInstance.Remove(key);
    }
}

// Globa.asax.cs: Inject cache dependency into CacheManager facade
public class Global: HttpApplication
{
    public void Application_Start(object sender, EventArgs e)
    {
        ICache cache = new SessionCache();
        CacheManager.CacheInstance = cache;
    }
}

// Model object with lazy-loaded, cached data
public class ModelEntity
{
    public object LazyLoadedObject
    {
        object item = CacheManager.Get("LazyLoadedObject");
        if (item == null)
        {
            item = GetLazyLoadedObject();
            CacheManager.Add("LazyLoadedObject", item);
        }

        return item;
    }

    private object GetLazyLoadedObject()
    {
        // TODO: Place retrieval logic here
    }
}

// Unit tests
[TestClass]
public class ModelEntityTests
{
    public void LazyLoadedObject_Get_AlreadyCached()
    {
        ICache cache = new DictionaryCache();
        CacheManager.CurrentCache = cache;
        
        object originalInstance = new object();

        cache.Add("LazyLoadedObject", originalInstance);

        ModelEntity entity = new ModelEntity();
        
        object cachedInstance = entity.LazyLoadedObject;

        Assert.AreEqual(originalInstance, cachedInstance);
    }    
}