c# - Entity Framework : single database, 多个上下文，正确处理事务

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 分布式事务协调器)有关，即避免将事务提升为分布式事务。
如果满足以下所有条件，则交易似乎不会提升:

1. 使用单一数据库
2. 上下文使用相同的连接字符串
3. 上下文使用相同的连接(对此不是 100% 确定)

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

然而，我最关心的是这个 Stack Overflow 问题的已接受答案下的评论:One transaction with multiple dbcontexts .这些评论可能暗示事务被提升为“轻量级”分布式事务(无论是什么)。无论如何，评论者认为这种方法非常危险。那是对的吗？但是 TransactionScope 首先的目的是什么？

作为旁注:我做了一些粗略的性能测量(对上述两种方法中的每一种调用 5000 次)并发现:

1. BeginTransaction() 比 TransactionScope 稍快。
2. 这两个版本显然比完全不使用事务要快。我原本没想到。也许是因为只需要创建一个连接？

Answer 1

我在同一个上下文中对多个过程进行了此操作，从未对两个单独的上下文进行过此操作。它应该在理论上工作相同，但在理论上:

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

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