我在 stackoverflow 上搜索，没有找到类似的问题，如果已经有请指出我。

我试图通过同步和异步操作实现一个通用的可重用存储库，但由于我对 Entity Framework 和工作单元知之甚少，我正在努力寻找实现它的正确方法。

我在 SaveAndCommit 操作上添加了一些变体，但不知道使用事务和异步执行此操作的最佳方法是什么。

----Edit----

As per my understanding transactions should be used when more than one operations is performed but for understanding purposes I used it for one operation. (Please correct me if I'm wrong)

这是我目前所做的

public class Service<TEntity> : IService<TEntity>
    where TEntity : Entity
{
    #region Constructor and Properties

    UnitOfWork _unitOfWork { get { return UnitOfWork.UnitOfWorkPerHttpRequest; } }

    protected DbSet<TEntity> Entities
    {
        get { return _unitOfWork.Set<TEntity>(); }
    }

    #endregion Constructor and Properties


    #region Operations

    public virtual IQueryable<TEntity> QueryableEntities()
    {
        return Entities;
    }

    public virtual async Task<IList<TEntity>> WhereAsync(Expression<Func<TEntity, bool>> predicate)
    {
        return await Entities.Where(predicate).ToListAsync();
    }

    public virtual IList<TEntity> Where(Expression<Func<TEntity, bool>> predicate)
    {
        return Entities.Where(predicate).ToList();
    }

    public virtual async Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> predicate)
    {
        return await Entities.FirstOrDefaultAsync(predicate);
    }

    public virtual TEntity FirstOrDefault(Expression<Func<TEntity, bool>> predicate)
    {
        return Entities.FirstOrDefault(predicate);
    }

    public virtual async Task<TEntity> GetByIdAsync(int id)
    {
        return await Entities.FindAsync(id);
    }

    public virtual TEntity GetById(int id)
    {
        return Entities.Find(id);
    }

    // Method to the change the EntityState
    public virtual void Save(TEntity entity)
    {
        if (entity.Id == 0)
        {
            Entities.Add(entity);
        }
        else
        {
            _unitOfWork.Entry(entity).State = EntityState.Modified;
        }
    }

    #region Need clarification here

    // Uses transaction scope to commit the entity and dispose automatically
    // call rollback but this is not async and don't have any async
    // functions (Or I could not find)
    public virtual void SaveAndCommit(TEntity entity)
    {
        using (var transaction = _unitOfWork.BeginTransaction())
        {
            try
            {
                Save(entity);
                transaction.Commit();
            }
            catch (DbEntityValidationException e)
            {
            }
        }
    }

    // This is asynchronous but don't uses transaction
    public virtual async Task SaveAndCommitAsync(TEntity entity)
    {
        try
        {
            Save(entity);
            await _unitOfWork.SaveChangesAsync();
        }
        catch (DbEntityValidationException e)
        {
        }
    }

    // Tried to mix async and transaction but don't know if it will actually         
    // work or correct way of doing this
    public virtual async Task SaveAndCommitWithTransactionAsync(TEntity entity)
    {
        using (var transaction = _unitOfWork.BeginTransaction())
        {
            try
            {
                Save(entity);
                await _unitOfWork.SaveChangesAsync();
            }
            catch (DbEntityValidationException e)
            {
                transaction.Rollback();
            }
        }
    }

    #endregion Need clarification here
    
    public virtual async Task DeleteAsync(TEntity entity)
    {
        if (entity == null) return;

        Entities.Remove(entity);
        await _unitOfWork.SaveChangesAsync();
    }

    //All similar methods for delete as for Save

    public virtual async Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate = null)
    {
        if (predicate != null)
        {
            return await Entities.CountAsync(predicate);
        }

        return await Entities.CountAsync();
    }

    #endregion Operations

}

请指导我并提出实现此目标的最佳方法。

Now it seems that the correct way to implement a transaction scope with async call would be

public virtual async Task SaveAndCommitWithTransactionAsync(TEntity entity)
    {
        using (var transaction = _unitOfWork.BeginTransaction())
        {
                Save(entity);
                await _unitOfWork.SaveChangesAsync();

                // Still no changes made to database
                transaction.Commit();
            
               //Rollback will automatically be called by using in dispose method
        }
    }

引用文献 MSDN Reference

Blog with more clear description

visualstudiomagazine.com 对于:当您调用 SaveChanges 时，您的任何更改都不会生效，直到您调用 Transaction 对象的 Commit 方法

最佳答案

编辑:

为了让事务范围与 async-await 一起工作，从 .NET 4.5.1 开始，您可以将 TransactionScopeAsyncFlowOption.Enabled 标志传递给它的构造函数:

using (var scope = new TransactionScope(... ,
  TransactionScopeAsyncFlowOption.Enabled))

这确保了事务范围在延续时表现良好。 有关更多信息，请参见 Get TransactionScope to work with async / await。

请注意此功能自 .NET 4.5.1 起可用。

编辑 2:

好的，@Jcl 对 BeingTransaction 发表评论后，我搜索并找到了 this answer :

With the introduction of EF6, Microsoft recommends to use new API methods: Database.BeginTransaction() and Database.UseTransaction(). System.Transactions.TransactionScope is just old style of writing transactional code.

But Database.BeginTransaction() is used only for database related operations transaction, whereas System.Transactions.TransactionScope makes the possible 'plain C# code' also transactional.

TransactionScope 的新异步特性的局限性:

• 需要 .NET 4.5.1 或更高版本才能使用异步方法。

• 它不能用于云场景，除非你确定你有一个 而且只有一个连接(云端场景不支持分布式
  交易)。

• 它不能与 Database.UseTransaction() 方法相结合 前面的部分。

• 如果您发出任何 DDL(例如，因为
  数据库初始化器)并且没有启用分布式事务
  通过 MSDTC 服务。

考虑到限制，似乎从 EF6 及更高版本开始的新方法是使用 Database.BeginTransaction() 而不是 TransactionScope。

总结:

这是编写异步事务范围内的数据库调用的正确方法:

public virtual async Task SaveAndCommitWithTransactionAsync(TEntity entity)
{
    using (var transaction = _unitOfWork.BeginTransaction())
    {
        try
        {
            Save(entity);
            await _unitOfWork.SaveChangesAsync();

            transaction.Commit();
        }
        catch (DbEntityValidationException e)
        {
        }
    }
}

请注意，如果您的范围包含在 using 语句中，则不应调用 transaction.RollBack()，因为如果提交是，它将进行回滚不成功。

相关问题:Entity Framework 6 transaction rollback

This related article 进一步阐明了新的 API

边注:

这段代码:

public virtual void SaveAndCommitAsync(TEntity entity)
{
    try
    {
        Save(entity);
        _unitOfWork.SaveChangesAsync();
    }
    catch (DbEntityValidationException e)
    {
    }
}

没有做您认为正在做的事情。当您执行一个异步方法时，您应该通常使用await 关键字异步等待它。这个方法:

1. 正在使用 void 作为其返回类型。如果这是一个异步 API，它需要至少 async Task。 async void 方法仅适用于事件处理程序，这里显然不是这种情况

2. 最终用户可能会等待这个方法，它应该变成:

   public virtual Task SaveAndCommitAsync(TEntity entity)
   {
      try
      {
          Save(entity);
          return _unitOfWork.SaveChangesAsync();
      }
      catch (DbEntityValidationException e)
      {
      }
   }
   

如果你想包含一个Transaction Scope，那么必须等待这个方法:

public virtual async Task SaveAndCommitAsync(TEntity entity)
{
    try
    {
        Save(entity);
        await _unitOfWork.SaveChangesAsync();
    }
    catch (DbEntityValidationException e)
    {
    }
}

其余的异步方法也是如此。一旦存在事务，请确保等待该方法。

此外，不要像那样吞下异常，对它们做一些有用的事情，或者干脆不捕获。

关于c# - Entity Framework 6 异步操作和 TranscationScope，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28133801/