告别事务混乱：Dapper工作单元模式的5步落地指南

告别事务混乱：Dapper工作单元模式的5步落地指南

【免费下载链接】Dapper Dapper - a simple object mapper for .Net 项目地址: https://gitcode.com/gh_mirrors/da/Dapper

你是否还在为分布式事务中的数据一致性问题头疼？是否因重复编写事务管理代码而降低开发效率？本文将带你用Dapper实现工作单元模式，通过统一事务管理方案，让你的数据操作既安全又优雅。读完本文你将掌握：

• 工作单元模式在Dapper中的设计原理
• 5步实现事务统一管理的完整流程
• 并发场景下的事务隔离策略
• 与TransactionTests.cs测试案例的集成方法

什么是工作单元模式？

工作单元（Unit of Work）模式作为一种数据访问层设计模式，主要解决三个核心问题：

1. 事务一致性：确保多个操作要么全部成功，要么全部失败
2. 资源管理：统一管理数据库连接的创建与释放
3. 代码复用：避免事务管理逻辑的重复编写

在Dapper中实现该模式具有天然优势，因为Dapper提供了对IDbTransaction接口的原生支持，所有核心方法如Execute、Query等都预留了transaction参数：

// [Dapper/SqlMapper.cs](https://link.gitcode.com/i/bb0f132953742599379202b19ad9b04f)中的事务支持
public static int Execute(this IDbConnection cnn, string sql, object? param = null, 
                         IDbTransaction? transaction = null, int? commandTimeout = null, 
                         CommandType? commandType = null)

实现步骤1：设计工作单元接口

首先定义IUnitOfWork接口，包含事务管理的核心方法：

public interface IUnitOfWork : IDisposable
{
    IDbTransaction Transaction { get; }
    void BeginTransaction();
    void Commit();
    void Rollback();
}

该接口抽象了事务的生命周期管理，符合"依赖倒置原则"，便于后续扩展不同数据库实现。

实现步骤2：创建Dapper工作单元

基于接口实现DapperUnitOfWork类，封装Dapper的事务操作：

public class DapperUnitOfWork : IUnitOfWork
{
    private readonly IDbConnection _connection;
    private IDbTransaction _transaction;
    
    public DapperUnitOfWork(IDbConnection connection)
    {
        _connection = connection;
        if (_connection.State != ConnectionState.Open)
            _connection.Open();
    }
    
    public IDbTransaction Transaction => _transaction;
    
    public void BeginTransaction()
    {
        _transaction = _connection.BeginTransaction();
    }
    
    public void Commit()
    {
        _transaction?.Commit();
        Dispose();
    }
    
    public void Rollback()
    {
        _transaction?.Rollback();
        Dispose();
    }
    
    public void Dispose()
    {
        _transaction?.Dispose();
        _connection?.Close();
    }
}

关键设计点：

• 在构造函数中自动打开连接
• 实现IDisposable接口确保资源释放
• 使用可空运算符处理事务空值情况

实现步骤3：集成仓储层

为具体业务创建仓储类，通过构造函数注入工作单元：

public class ProductRepository
{
    private readonly IDbConnection _connection;
    private readonly IUnitOfWork _unitOfWork;
    
    public ProductRepository(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
        _connection = unitOfWork.Transaction.Connection;
    }
    
    public void AddProduct(Product product)
    {
        _connection.Execute(
            "INSERT INTO Products (Id, Name) VALUES (@Id, @Name)",
            product,
            transaction: _unitOfWork.Transaction
        );
    }
}

注意这里必须显式传递transaction参数，这是Dapper事务管理的关键。

实现步骤4：服务层事务协调

在业务服务中组合多个仓储操作，实现跨仓储事务：

public class OrderService
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly OrderRepository _orderRepo;
    private readonly ProductRepository _productRepo;
    
    public OrderService(IUnitOfWork unitOfWork, OrderRepository orderRepo, ProductRepository productRepo)
    {
        _unitOfWork = unitOfWork;
        _orderRepo = orderRepo;
        _productRepo = productRepo;
    }
    
    public void CreateOrder(Order order, List<Product> products)
    {
        try
        {
            _unitOfWork.BeginTransaction();
            
            _orderRepo.AddOrder(order);
            foreach (var product in products)
            {
                _productRepo.AddProduct(product);
            }
            
            _unitOfWork.Commit();
        }
        catch (Exception)
        {
            _unitOfWork.Rollback();
            throw;
        }
    }
}

实现步骤5：测试验证

参照Dapper官方测试案例TransactionTests.cs，编写单元测试验证事务行为：

[Fact]
public void CreateOrder_WithProducts_CommitsTransaction()
{
    // Arrange
    using var connection = new SqlConnection("connectionString");
    using var unitOfWork = new DapperUnitOfWork(connection);
    var orderRepo = new OrderRepository(unitOfWork);
    var productRepo = new ProductRepository(unitOfWork);
    var service = new OrderService(unitOfWork, orderRepo, productRepo);
    
    // Act
    service.CreateOrder(new Order { Id = 1 }, new List<Product> { new Product { Id = 1 } });
    
    // Assert
    var orderCount = connection.Query<int>("SELECT COUNT(*) FROM Orders WHERE Id = 1").Single();
    var productCount = connection.Query<int>("SELECT COUNT(*) FROM Products WHERE Id = 1").Single();
    
    Assert.Equal(1, orderCount);
    Assert.Equal(1, productCount);
}

高级应用：并发控制与隔离级别

在高并发场景下，可通过指定事务隔离级别增强数据一致性：

public void BeginTransaction(IsolationLevel isolationLevel = IsolationLevel.ReadCommitted)
{
    _transaction = _connection.BeginTransaction(isolationLevel);
}

常用隔离级别选择指南：

• ReadCommitted：默认级别，防止脏读
• RepeatableRead：防止不可重复读
• Serializable：最高隔离级别，防止幻影读
• ReadUncommitted：最低隔离级别，性能最优

与官方测试案例的对比分析

Dapper官方测试中采用基础事务管理方式：

// [TransactionTests.cs](https://link.gitcode.com/i/0fd4212beaa7b94e3758e27fe0dce017)中的原生事务测试
using (var transaction = connection.BeginTransaction())
{
    connection.Execute("insert into #TransactionTest values (1, 'ABC');", transaction: transaction);
    transaction.Commit();
}

工作单元模式与之相比的优势：

1. 更好的代码组织性：事务逻辑与业务逻辑分离
2. 更强的可维护性：集中管理事务生命周期
3. 更好的可测试性：依赖注入便于模拟
4. 更少的重复代码：避免到处编写try-catch块

总结与最佳实践

采用工作单元模式管理Dapper事务时，建议遵循以下最佳实践：

1. 使用依赖注入：通过容器管理工作单元生命周期
2. 限定作用域：每个请求创建一个工作单元实例
3. 及时释放资源：确保Dispose方法被正确调用
4. 异常处理：在服务层统一捕获并处理异常
5. 测试覆盖：至少覆盖提交、回滚和并发场景

通过本文介绍的5步实现方案，你可以在Dapper项目中构建健壮的事务管理机制，有效解决分布式系统中的数据一致性问题。完整实现代码可参考官方文档docs/index.md和测试案例tests/Dapper.Tests/。

点赞+收藏+关注，下期将带来《Dapper性能优化：缓存策略与查询调优》，深入探讨如何进一步提升Dapper应用的性能表现。

【免费下载链接】Dapper Dapper - a simple object mapper for .Net 项目地址: https://gitcode.com/gh_mirrors/da/Dapper