使用带有ORM（EF6）的自定义UOW的并行事务问题

Question

A little background I'm trying to implement Generic Repository and UOW pattern along with Entity Framework as ORM.I have written custom UnitOFWork class with methods

1.BeginTransaction. 2.CommmitTransaction 3.RollBackTransaction 4.SaveChanges 5.IsInTransaction 6.Dispose.

public class UnitOfWork: IUnitOfWork
{
  private DbTransaction transaction;
  private readonly DbContext context;
  public UnitOfWork(DBContext dbContext )
  {
    context = dbContext ;
  }   
  public void Begintransaction()
  {
    transaction = context.Database.Connection.BeginTransaction(isolationLevel);
  }
  public void CommitTransaction()
  {
    context.SaveChanges();
    transaction.Commit();
    ReleaseCurrentTransaction();
  }
   ....
   ....
}

My Generic repository class

public class Repository : IRepository
{
  private dbContext;
  protected DBContext Context
  {
     get
     {
       return dbContext != null? dbContext : dbContext = GetContextFromFactory();
     }
  }
  public void Add<T>(T entity)
  {
    dbContext.Set<T>.Add(entity);
  }
}

My PersonRepository.

public class PersonRepository : Repository
{
  public void AddPerson(Person person)
  {
     using(var uow = new UnitOfWork(Context)
     {
       try
       {
         uow.BeginTransaction();
         Add(person);
         uow.CommitTransaction();
       }
       catch (Exception ex)
       {
         uow.RollBackTransaction();
     log.Error("This Exception:",ex);
       }
     }
  }
} 

var repo = new PersonRepository();
Person person = GetPerson();
repo.AddPerson(person);  

When I run this code to save person object it throws exception on context.SaveChanges() in CommitTransaction() method of UOW. Exception is "SqlConnection does not support parallel transactions."

1. Am I doing something wrong in the code?
2. Transactions in UOW has some issues?
3. UOW transactions in conjunction with ORM are not supported?
4. If transactions are not supported then what is the purpose of UnityOfWork pattern when DbContext or any other ORM implements unitofwork pattern by default?

I would appreciate your suggestions and comments.

[Update] I have fixed this issue by making context to accept current transaction which is already existing. My fix was in the code CommitTransaction().I need your comments.

From this.

  public void CommitTransaction()
  {
   context.SaveChanges();
    transaction.Commit();
    ReleaseCurrentTransaction();
  }

To This.

 public void CommitTransaction()
  {
    context.UseTransaction(this.transaction);
    context.SaveChanges();
    transaction.Commit();
    ReleaseCurrentTransaction();
  }

Are there any downside for this approach? Please share your comments.

Answer 1

1. DbContext is NOT threadsafe - do not use dbcontext across threads.
2. Connection strings should make sure connections allow MARS. See Below.
3. UoW patterns are best practice with ORMs. Supported by EF.
4. EF framework manage the transaction for you. No need to add Transaction handling to your basic repository class.
   add object 1, change object2, remove object 3,
   Then SaveChanges.
   Will be performed as a transaction by EF. Without dirty uncommitted reads. If one of the updates fails, the changes are rolled back.

5. Transactions via message queues. EF and transaction scope for use with message queues General info on when you might want to use transactions in EF Considerations for using transactions and how to in EF

6. Dispose of your Context instance ASAP. Renew regularly is general recommendation

connection String: see MultipleActiveResultSets=true

 <connectionStrings>
    <add name="myConn" connectionString="Data Source=localhost;Initial Catalog=MyDbName ;Integrated Security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
</connectionStrings>