One DbContext Instance spans multiple Repositories

Question

These are my AutoFac-DI definitions in my Web Api setup:

 builder.RegisterType<MyContext>().As<MyContext>().InstancePerRequest();
 builder.RegisterType<TestRepository>().InstancePerRequest();
 builder.RegisterType<SchoolclassCodeRepository>().InstancePerRequest();
 builder.RegisterType<TestService>().InstancePerRequest();

The TestService constructor accepts the TestRepository and SchoolclassCodeRepository. Both Repositories accepts the same Instance of the MyContext.

I agree with this: Is it wise to use same DbContext with multiple repositories?

There are other good reasons to share a context though, one of which (IMHO) is that the context has to track the state of an entity, if you're get an entity, dispose the context, make some modifications to the entity, and then attach to a new context this new context has to go hit the database so it can figure out the state of the entity. Likewise if you're working with graphs of entities (Invoices, and all their InvoiceItems), then the new context would have to fetch all the entities in the graph to determine their state.

But now I hit a one-way street with this architecture!

What if I have to do a transaction spanning multiple repositories?

With EF6 you do it like that without Repositories:

using(NorthwindEntities db = new NorthwindEntities())
{
    DbContextTransaction transaction = db.Database.BeginTransaction();

    try
    {
        //insert record 1
        Customer obj1 = new Customer();
        obj1.CustomerID = "ABCDE";
        db.Customers.Add(obj1);
        db.SaveChanges();

        //insert record 2
        Customer obj2 = new Customer();
        obj2.CustomerID = "PQRST";
        db.Customers.Add(obj2);   
        db.SaveChanges();

        transaction.Commit();
    }
    catch
    {
        transaction.Rollback();
    }
}

When I take now the above sample and try to do the same with my 2 repositories within the service, then I face a serious problem.

• I have no DbContext available in my Service.
• The DbContext is a DataProvider/Layer concern and should stay inside the repository.

How can I create then a transaction over multiple repositories without changing my repositories?

Sample what I want:

Inside my TestService I want to do roughly:

public void Save()
{
  // Open Transaction
  // testRepo.Insert();
  // schoolclassCodeRepo.Delete();
  // Commit Transaction
}

UPDATE

In my TestService I map all entities from the repos to DTO objects which are then enriched by data + links (Rest) in my web api controllers.

UPDATE 2

• The Repository pattern makes data access methods reusable thats good.
• But it makes a transaction over multiple repositories sharing same DbContext not possible.

WOULD it not be better to implement all Repository methods as extension methods of the DbContext, this way I could call the "Repo extension methods" in my Service directly on the ONE DbContext injected into my TestService?

UPDATE 3 Solution code

public async Task<bool> DeleteSchoolyearAsync(int id)
{
    using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
    {
        try
        {
            await testRepository.DeleteTestTypes(id);
            await schoolyearRepository.DeleteAsync(id);
            scope.Complete(); // Rollback is done due to using statement...
            return true;

        }
        catch (System.Exception)
        {
            return false;
        }
    }
}

This code worked fine!

Answer 1

You can do this by using transaction scope instead of a dbcontexttransaction:

using (var scope = new TransactionScope(TransactionScopeOption.Required,
                                            new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }))
    {

  // Your code

 scope.Complete();

}

Note when you use this across databases it will use MSDTC.

Answer 2

You don't change your repositories but you definitely lack the Unit of Work in your architecture. This is where you share a single context for multiple repositories.

Think of the UoW as the DbContext where repositories are DbSets.

UoW uow = new UoW( context );

uow.BeginTransaction();

uow.Repository1.... // query, insert, update, delete
uow.Repository2....

uow.Commit();

A typical implementation just exposes multiple repositories:

public class UoW {

   public UoW( DbContext ctx ) {

      this._ctx = ctx;

   }

   private Repository1 _repo1;

   public Repository1 Repo1
   {
      get
      {
          if ( _repo1 == null )
              _repo1 = new Repository1( this._ctx );
          return _repo1;
      }

      ...

If you need a good and complete tutorial on that, take a look here:

http://www.asp.net/mvc/overview/older-versions/getting-started-with-ef-5-using-mvc-4/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application