使用PetaPoco結合注入實現業務級事務

PetaPoco是一個輕量級ORM，我的MVC項目中使用它結合Repository模式，依靠Unity的生命周期管理對象，保證請求/線程級別的數據上下文單例，並使用鎖和計數實現業務級事務。下文代碼依個人理解實現，謬誤請不吝指正。

例行IUnitOfWork：

public interface IUnitOfWork
{
    void Begin();
    void Commit();
    void Rollback();
}

倉庫上下文核心：

public class PetaPocoUnitOfWork : IUnitOfWork
{
    private const String _dbName = "Northwind";
    private Boolean _requireAbort = false;
    private Int32 _transactionDepth = 0;
    private Object _transactionLock = new Object();

    public Database DBContext { get; protected set; }

    public Guid Id { get; private set; }

    public PetaPocoUnitOfWork()
    {
        Id = Guid.NewGuid();
        DBContext = new Database(_dbName);
    }

    public void Begin()
    {
        lock (_transactionLock)
        {
            if (_transactionDepth == 0)
            {
                DBContext.BeginTransaction();
            }
            _transactionDepth++;
        }

    }

    public void Commit()
    {
        lock (_transactionLock)
        {
            _transactionDepth--;
            if (_transactionDepth == 0)
            {
                try
                {
                    DBContext.CompleteTransaction();
                }
                catch
                {
                    _transactionDepth++;
                    _requireAbort = true;
                    throw;
                }
            }
        }
    }

    public void Rollback()
    {
        lock (_transactionLock)
        {
            _transactionDepth--;
            if (_transactionDepth == 0)
            {
                DBContext.AbortTransaction();
                _requireAbort = false;
            }
        }
    }

    public void Dispose()
    {
        if (_requireAbort)
        {
            DBContext.AbortTransaction();
        }
        DBContext.Dispose();
    }
}

在應用層對Unity注入的IUnitOfWork調用Begin()即開啟事務，對於嵌套事務變量_transactionDepth++記錄事務深度，Commit()與Rollback()時_transactionDepth--，保證業務中事務只開啟與提交一次。如有應用層ITradeService及實現：

public abstract class ApplicationService {
    public IUnitOfWork Context { get; private set; }

    public ApplicationService(IUnitOfWork context) {
        Context = context;
    }
}

public interface ITradeService {
    void SubmitOrder(Order model);
}

public class TradeService : ApplicationService, ITradeService {
    private readonly IOrderRepository _orderRepository;
    private readonly IOrderDetailRepository _orderDetailRepository;

    public TradeService(
        IUnitOfWork context,
        IOrderRepository orderRepository,
        IOrderDetailRepository orderDetailRepository)
        : base(context) {
        _orderRepository = orderRepository;
        _orderDetailRepository = orderDetailRepository;
    }

    void SubmitOrder(OrderDTO model){
        //do something, like null reference check etc..

        Order order = //... some logic
        OrderDetail orderDetail =  //as above

        try {
            Context.Begin();

            _orderRepository.Update(order);
            _orderDetailRepository.Update(orderDetail);
            //could be more complex

            Context.Commit();
        }
        catch {
            Context.Rollback();
            throw;
        }
    }
}

當顧客提交訂單時，Context.Begin()開啟一個事務鎖，由於Unity的生命周期管理，當前線程內的數據上下文實例是同一個對象，故能夠保證事務。當事務發生嵌套時，事務深度的解決方法發生作用，比如以可測試性的提高截取部分代碼示例：

[TestClass]
public class AccountServiceTest {
    [TestMethod]
    public void TradeServiceTest_SubmitOrder() {
        IUnitOfWork context = ... //some initialize logic
        OrderDTO model = ... //as above
        TradeService service = //as above

        context.Begin();
        service.SubmitOrder();
        context.Rollback();
        ///... etc
    }
}