如何管理子事务或嵌套事务？

Question

我想要有一些类似于子交易的事情，因为您可以标记一个点，您可以开始子交易，然后在该位的决定点处，您可以回滚（中止子位）或进行有效的承诺，当出场转换承诺时。当然，如果您中止外部交易，标记位也会中止。

我如何能做到这一点与NHibernate，但交易最前一页期间被关闭承诺，因此我真的有错误消息

没有打开的事务提交

我的代码如下：

API.Data.Session session = API.Data.SessionManager.GetSession(); 
     session.BeginTransaction(); 
     try 
     { 
      Project project = Project.Load(ID); 
      ........... 
      Save(project); 
      ..................... 

      session.CommitTransaction(); 
     } 
     catch 
     { 
      session.RollbackTransaction(); 
      throw; 
     } 

---

public void save(Project project) 
    { 
Data.SessionManager.GetSession().BeginTransaction(); 
       try 
       { 
        Save(); 
        LogIssueChange(test); 
        Data.SessionManager.GetSession().CommitTransaction(); 
       } 
       catch 
       { 
        Data.SessionManager.GetSession().RollbackTransaction(); 
        throw; 
       } 
    } 

Answer 1

的本地支持经由嵌套的事务提供和TransactionScope类。请注意，AFAIK这是由Sql Server和Oracle支持的，尽管它可能适用于其他数据库，如果它们支持分布式事务以及插入到System.Data的API也支持它。

看到这些SO问题https://stackoverflow.com/questions/tagged/nhibernate+transactionscope

Answer 2

你不能，NHibernate不支持嵌套事务。您可以通过Systems.Transaction命名空间来实现此目的。

---

编辑：DeferableTransaction实现如下。我有这个作为ISession的扩展方法。这就是说，使用情况非常罕见。

扩展方法：

public static DeferableTransaction BeginOrDeferTransaction(this ISession session) 
    { 
     return new DeferableTransaction(session); 
    } 

    public static DeferableTransaction BeginOrDeferTransaction(this ISession session, IsolationLevel isolationLevel) 
    { 
     return new DeferableTransaction(session, isolationLevel); 
    } 

实现：

/// <summary> 
/// Begins a transaction or defers to an existing transaction. The IsolationLevel will not be changed 
/// on an existing transaction. 
/// </summary> 
public class DeferableTransaction : IDisposable 
{ 
    private readonly bool _ownedTransaction; 
    private readonly ITransaction _transaction; 

    public DeferableTransaction(ISession session) 
     : this(session, IsolationLevel.ReadCommitted) 
    {} 

    public DeferableTransaction(ISession session, IsolationLevel isolationLevel) 
    { 
     if (session.Transaction.IsActive) 
     { 
      _ownedTransaction = false; 
      _transaction = session.Transaction; 
     } 
     else 
     { 
      _ownedTransaction = true; 
      _transaction = session.BeginTransaction(isolationLevel); 
     } 
    } 

    public bool OwnedTransaction 
    { 
     get { return _ownedTransaction; } 
    } 

    public void CommitOrDefer() 
    { 
     if (_ownedTransaction) 
     { 
      _transaction.Commit(); 
     } 
    } 

    public void RollbackOrDefer() 
    { 
     if (_ownedTransaction) 
     { 
      _transaction.Rollback(); 
     } 
    } 

    public void Enlist(IDbCommand command) 
    { 
     _transaction.Enlist(command); 
    } 

    public bool IsActive 
    { 
     get { return _transaction.IsActive; } 
    } 

    public bool WasCommitted 
    { 
     get { return _transaction.WasCommitted; } 
    } 

    public bool WasRolledBack 
    { 
     get { return _transaction.WasRolledBack; } 
    } 

    public void Dispose() 
    { 
     if (_ownedTransaction) 
     { 
      _transaction.Dispose(); 
     } 
    } 
}