Question

I use the following, static class to access the data context in my application

public static class DataContext
{
    internal const string _contextDataKey = "dataContext";

    /// <summary>
    /// Returns a unique data context that lives for the duration of the request, which can be from ASP.NET or a WCF service
    /// </summary>
    /// <returns>The entity data model context for the current request</returns>
    public static EntityDataModelContext GetDataContext()
    {
        IPersistanceContainer state;

        if (HttpContext.Current != null)
        {
            state = new AspNetPersistanceContainer();
        }
        else if (OperationContext.Current != null)
        {
            state = new WcfPersistanceContainer();
        }
        else
        {
            state = new StaticPersistanceContainer(); // this container is thread-unsafe.
        }

        EntityDataModelContext edm = state.Get<EntityDataModelContext>(_contextDataKey);
        if (edm == null)
        {
            edm = new EntityDataModelContext();
            state.Store(_contextDataKey, edm);
        }

        return edm;
    }
}

Forget about the other containers, which are for WCF and Console application simple-tests respectively, here’s the ASP.NET container:

internal class AspNetPersistanceContainer : IPersistanceContainer
{
    public T Get<T>(string key) where T : class
    {
        if (HttpContext.Current.Items.Contains(key))
            return (T)HttpContext.Current.Items[key];

        return null;
    }

    public void Store(string key, object value)
    {
        HttpContext.Current.Items[key] = value;
    }
}

When I need to access the context I just invoke DataContext.GetDataContext() and do my DB-accessing, I never add any using statements.

If I add a using statement, the context is good for one use, and the next time I try to use it, it’s disposed of. Raising an exception.

If I don’t, like right now, it makes me kind of unhappy, I feel like it’s not the right thing to do either, not disposing of it.

So I was wondering what would be the correct thing to do here.

Is this design flawed, and should I abandon it altogether?

Should I just figure out a way to re-create the context whenever it’s disposed of?

Should I just leave the design as is, and that’s fine?

Maybe the design is “fine enough”, are there any books that you’d recommend I read on the subject? I feel like my skills on back-end architecture are rather on the lacking side.

Answer 1

In an asp.net application one solution can be like this :

1. Create your context when a request begins
2. Dispose it when the request ends

Here‘s an article that discuss this approach (for NHibernate session management but it’s almost the same for EF )