Declaring Entity FrameWork Contexts with using

Question

Which is the Best Practise in Declaring Entity FrameWork Contexts

function()
{
    DBContext context = new DBContext();

    //Entity code

    return ;
}


        

Answer 1

Your request will be executed toward the datasource as soon as you'll call .ToList() method.

That's why you cannot perform .ToList() in your Controller as your context as been disposed at the end of the using block.

In your DL method, just do something like:

IEnumerable<Something> function()
{
    using(DBContext context = new DBContext())
    {
      return something.ToList();
    }
}

and in your Controller you'll get an IEnumerable of Something:

var mySomethingIEnumerable = DL.Function();

Hope that helps!

Answer 2

Yes, a using is the best practice because it cleans up your context. The Using statement is a shortcut for:

try {
    // Execute your code inside the using statement
}
finally {
    // Cleanup the context no matter what by calling .Dispose()
}

Keep in mind, your context likely returns IEnumerables and since EF supports lazy loading these objects won't be populated until you fetch them to a concrete collection (ie. yourResult.ToList()).

A common negative outcome occurs in this scenario:

public IEnumerable<Employee> GetEmployeesInAccounting()
{
    using(var myContext = new MyDbContext())
    {
        return myContext.Employees.Where(emp => emp.Department == 'Accounting');
    }
}

// Code that fails, Assuming Manager is a lazy loaded entity, this results in an exception but it compiles no problem
var acctEmps = GetEmployeesInAccounting();
var something = acctEmps.First().Department.Manager.Department;

You can avoid this by using the .Include(emp => emp.Manager) (linq extension method) and binding your result using .ToList();

Answer 3

You can avoid the lazy-loading EF behaviour by calling .ToList() on the IEnumerable before the context is disposed (i.e. within your using block)