Question

我想在我当前的项目中使用多个上下文/模式，但我不能确定在单个事务中将写入访问包装到上下文的正确方法。

我的理解是有两种方法可以实现这一目标：DbContext.Database.BeginTransaction()和TransactionScope。我不确定的是我是否正确使用它们和/或是否有其他方法可以做到这一点。

示例：
假设以下模型/上下文：

public class A
{
   [Key]
   public int Id { get; set; }
   public string Name { get; set; }
}

public class ContextA : DbContext
{
   public ContextA() : base( "MultipleContextsTest" ) { }

   public DbSet<A> SetA { get; set; }

   protected override void OnModelCreating( DbModelBuilder modelBuilder )
   {
      modelBuilder.HasDefaultSchema( "SchemaA" );
      base.OnModelCreating( modelBuilder );
   }
}

然后假设第二个模型/上下文：

public class B
{
   [Key]
   public int Id { get; set; }
   public string OtherName { get; set; }
}

public class ContextB : DbContext
{
   public ContextB() : base( "MultipleContextsTest" ) { }

   public ContextB( DbConnection conn, bool ownsConnection = false ) 
     : base( conn, ownsConnection ) { }

   public DbSet<B> SetB { get; set; }

   protected override void OnModelCreating( DbModelBuilder modelBuilder )
   {
      modelBuilder.HasDefaultSchema( "SchemaB" );
      base.OnModelCreating( modelBuilder );
   }
}

然后我使用DbContext.Database.BeginTransaction()的方法如下：

void Using_BeginTransaction()
{
   using( ContextA contextA = new ContextA() )
   {
      using( var transaction = contextA.Database.BeginTransaction() )
      {
         contextA.SetA.Add( new A { Name = "Name" } );
         contextA.SaveChanges();

         using( ContextB contextB 
           = new ContextB( transaction.UnderlyingTransaction.Connection ) )
         {
            contextB.Database.UseTransaction( transaction.UnderlyingTransaction );
            contextB.SetB.Add( new B() { OtherName = "OtherName" } );
            contextB.SaveChanges();
         }

         transaction.Commit();
      }
   }
}

最让我担心的是，我找不到重新使用“外部”上下文与“内部”上下文的连接的示例。在文档中，它说事务是“外部的”，在我发现的示例中，到目前为止，事务并未用于在上下文之间传递。该交易用于运行SQLCommand，或者该交易来自从外部明确创建的SqlConnection收到的交易。
换句话说：我在问我是否滥用了可能不会以这种方式使用的功能。这也可能是因为连接和事务都不能直接传递给“内部”上下文，而是必须使用它们的“底层”版本。

我使用TransactionScope的方法如下：

void Using_TransactionScope()
{
   using( TransactionScope transaction = new TransactionScope() )
   {
      using( ContextA contextA = new ContextA() )
      {
         contextA.SetA.Add( new A { Name = "Name" } );
         contextA.SaveChanges();
      }

      using( ContextB contextB = new ContextB() )
      {
         contextB.SetB.Add( new B() { OtherName = "OtherName" } );
         contextB.SaveChanges();
      }

      transaction.Complete();
   }
}

这里我的担忧主要与MSDTC（Microsoft分布式事务协调器）有关，即避免将事务提升为分布式事务。
如果满足以下所有条件，那么交易似乎不会提升：

使用单个数据库
上下文使用相同的连接字符串
上下文使用相同的连接（不是100％肯定）

上下文使用相同的连接是保证还是可以实现？

但是，最让我担心的是此Stack Overflow问题的接受答案下的评论：One transaction with multiple dbcontexts。这些注释可能意味着事务被提升为“轻量级”分布式事务（无论是什么）。在任何情况下，评论者都认为这种方法非常危险。那是对的吗？但那么TransactionScope首先是什么目的呢？

作为旁注：我做了一些粗略的性能测量（对上述两种方法使用5000次调用）并发现：

BeginTransaction()略快于TransactionScope。
两个版本显然比完全不使用任何交易更快。我没想到的是。也许是因为只需要创建一个连接？

Answer 1

我在同一个上下文中为多个过程做了这个，从来没有两个单独的上下文。它应该在理论上起作用：

using (var ee = new EntitiesTest())
using (var transaction = new TransactionScope())
{
   ee.spMoneyUpdate(  ...)
   ee.spUpdateTotals();
   transaction.Complete();
}

如果范围无法完成，则应该回滚。意思是我想要全部或全部。如果第一个存储过程失败，我不希望下一个存储过程触发，第一个存储过程要回滚。我对TransactionScope的理解就是这样做。

实体框架：单个数据库，多个上下文，正确获取交易

1 个答案: