TransactionScope和实体框架

Question

I need to wrap some pieces of code around a TransactionScope . The code inside this using statement calls a managed C++ library, which will call some unmanaged code. I do also want to update my database, which is using Entity Framework.

Here comes the problem, when doing SaveChanges on the DbContext inside the TransactionScope I always get some sort of Timeout exception in the database layer. I've googled this, and it seems to be a fairly common problem but I haven't found any applicable answers to my problem. This is a snippet of my code

using (var transactionScope = new TransactionScope())
{
       try
       {
           //Do call to the managed C++ Library
           using (var dbContext = _dbContextFactory.Create())
           {
            //doing some CRUD Operations on the DbContext
            //Probably some more dbContext related stuff

            dbContext.SaveChanges(); //Results with a timeout 
           }
        }
        catch (Exception)
        {
          transactionScope.Dispose();
          throw;
        }
}

I'm using Entity Framework 6.1.3 so I can access the BeginTransaction on the database, but I also need wrap the C++ calls inside a TransactionScope .

Any suggestions?

Answer 1

You will need to pass in TransactionScopeOptions defining your timeout (How long to keep the transaction open). An example for the absolute upper limit of timeouts would be:

            TransactionOptions to = new TransactionOptions();
            to.IsolationLevel = IsolationLevel.ReadCommitted;
            to.Timeout = TransactionManager.MaximumTimeout;
            using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, to)) { }

You should definitely be aware of the impact of such a long-running transaction, this isn't typically required, and I'd highly recommend using something below MaximumTimeout which reflects how long you expect it to run. You should do your best to keep the time period for which the transaction is held as small as possible, doing any processing that doesn't have to be a single transaction outside the transaction scope.

It's also worth noting that depending on the underlying database it can enforce it's own limitations on transaction durations if configured to do so.