Proper use of "Using" statement for datacontext

c#, entity-framework, linq-to-entities

Solution

You can implement a Database factory which will cause your DbContext is being reused.

You can achieve this as follows:

DatabaseFactory class:

public class DatabaseFactory : Disposable, IDatabaseFactory
{
    private YourEntities _dataContext;
    public YourEntities Get()
    {
        return _dataContext ?? (_dataContext = new YourEntities());
    }
    protected override void DisposeCore()
    {
        if (_dataContext != null)
            _dataContext.Dispose();
    }
}

Excerpt of the Repository base class:

 public abstract class Repository<T> : IRepository<T> where T : class
{
    private YourEntities _dataContext;
    private readonly IDbSet<T> _dbset;
    protected Repository(IDatabaseFactory databaseFactory)
    {
        DatabaseFactory = databaseFactory;
        _dbset = DataContext.Set<T>();
    }

    protected IDatabaseFactory DatabaseFactory
    {
        get;
        private set;
    }

    protected YourEntities DataContext
    {
        get { return _dataContext ?? (_dataContext = DatabaseFactory.Get()); }
    }

Your table's repository class:

public class ApplicationRepository : Repository<YourTable>, IYourTableRepository
{
    private YourEntities _dataContext;

    protected new IDatabaseFactory DatabaseFactory
    {
        get;
        private set;
    }

    public YourTableRepository(IDatabaseFactory databaseFactory)
        : base(databaseFactory)
    {
        DatabaseFactory = databaseFactory;
    }

    protected new YourEntities DataContext
    {
        get { return _dataContext ?? (_dataContext = DatabaseFactory.Get()); }
    }

   }
    public interface IYourTableRepository : IRepository<YourTable>
   {
   }
}

This works perfectly together with AutoFac constructor injection as well.

Problem

I’m using Linq to Entities and lately, I found that a lot of folks recommending wrapping the datacontext in a using statement like this: ``` Using(DataContext db = new DataContext) { var xx = db.customers; } ``` This makes sense. However, I’m not sure how to incorporate this practice in my model. For example: I have an interface (let’s call it customer) and it is implemented by a repository like this: ``` namespace Models { public class rCustomer : iCustomer { readonly DataContext db = new DataContext(); public customer getCustomer(Guid id) { return db.customers.SingleOrDefault(por => por.id == id); } public iQueryable<customer> getTopCustomers() { return db.customers.Take(10); } //******************************************* //more methods using db, including add, update, delete, etc. //******************************************* } } ``` Then, to take the advantage of using, I will need to change the methods to look like this: ``` namespace Models { public class rCustomer : iCustomer { public customer getCustomer(Guid id) { using(DataContext db = new DataContext()) { return db.customers.SingleOrDefault(por => por.id == id); } } public iQueryable<customer> getTopCustomers() { using(DataContext db = new DataContext()) { return db.customers.Take(10); } } //******************************************* //more methods using db //******************************************* } } ``` My question is: the recommendation of using “Using” is really that good? Please take in consideration that this change will be a major one, I have about 25 interfaces/repository combos, and each has about 20-25 methods, not to mention the need to re-test everything after finish. Is there other way? Thanks! Edgar.

Original source