SqlHelper 实现类，支持多数据库，提供异步操作、自动重试、事务、存储过程、分页、缓存等功能。

/// <summary>
/// SqlHelper 实现类，支持多数据库，提供异步操作、自动重试、事务、存储过程、分页、缓存等功能。
/// </summary>
public class SqlHelper : IDbHelper
{
    private readonly IDbConnectionFactory _connectionFactory;
    private readonly ILogger<SqlHelper>? _logger;
    private readonly AsyncPolicy _retryPolicy;
    private readonly IRedisCacheHelper? _redisCacheHelper;

    /// <summary>
    /// 构造函数，注入数据库连接工厂，日志记录器，自动重试次数与延迟，以及可选 Redis 缓存。
    /// </summary>
    /// <param name="connectionFactory">数据库连接工厂</param>
    /// <param name="logger">日志记录器</param>
    ///<param name="retryCount">自动重试次数</param> 
    /// <param name="retryDelayMs">重试延迟（毫秒）</param> 
    /// <param name="redisCacheHelper">Redis 缓存（可空）</param> 
    public SqlHelper( IDbConnectionFactory connectionFactory, ILogger<SqlHelper>? logger = null, int retryCount = 3, int retryDelayMs = 200, IRedisCacheHelper? redisCacheHelper = null) 
    { 
        _connectionFactory = connectionFactory; 
        _logger = logger;
        _redisCacheHelper = redisCacheHelper;
        _retryPolicy = Policy.Handle<Exception>()
        .WaitAndRetryAsync(retryCount, _ => TimeSpan.FromMilliseconds(retryDelayMs),
        (ex, timespan, retryCount, context) =>
        {
            _logger?.LogWarning($"Retry {retryCount} in {timespan.TotalMilliseconds}ms due to: {ex.Message}");
        });
    }

    /// <summary>
    /// 获取数据库连接实例
    /// </summary>
    /// <returns>DbConnection 实例</returns>
    private DbConnection GetConnection() => _connectionFactory.CreateConnection();

    public async Task<IEnumerable<T>> QueryAsync<T>(string sql, object? parameters = null)
    {
        var sw = Stopwatch.StartNew();
        await using var conn = GetConnection();
        await conn.OpenAsync();

        var result = await _retryPolicy.ExecuteAsync(() => conn.QueryAsync<T>(sql, parameters));
        sw.Stop();

        _logger?.LogInformation($"[Query] {sw.ElapsedMilliseconds}ms - SQL: {sql}");
        return result;
    }

    public async Task<T> QueryFirstOrDefaultAsync<T>(string sql, object? parameters = null)
    {
        var sw = Stopwatch.StartNew();
        await using var conn = GetConnection();
        await conn.OpenAsync();

        var result = await _retryPolicy.ExecuteAsync(() => conn.QueryFirstOrDefaultAsync<T>(sql, parameters));
        sw.Stop();

        _logger?.LogInformation($"[QueryFirstOrDefault] {sw.ElapsedMilliseconds}ms - SQL: {sql}");
        return result;
    }

    public async Task<int> ExecuteAsync(string sql, object? parameters = null)
    {
        var sw = Stopwatch.StartNew();
        await using var conn = GetConnection();
        await conn.OpenAsync();

        var result = await _retryPolicy.ExecuteAsync(() => conn.ExecuteAsync(sql, parameters));
        sw.Stop();

        _logger?.LogInformation($"[Execute] {sw.ElapsedMilliseconds}ms - SQL: {sql}");
        return result;
    }

    public async Task<IEnumerable<T>> RunProcedureAsync<T>(string procName, object? parameters = null)
    {
        var sw = Stopwatch.StartNew();
        await using var conn = GetConnection();
        await conn.OpenAsync();

        var result = await _retryPolicy.ExecuteAsync(() => conn.QueryAsync<T>(procName, parameters, commandType: CommandType.StoredProcedure));
        sw.Stop();

        _logger?.LogInformation($"[RunProcedure] {sw.ElapsedMilliseconds}ms - Procedure: {procName}");
        return result;
    }

    public async Task ExecuteInTransactionAsync(Func<IDbHelper, Task> transactionalOperations)
    {
        await using var conn = GetConnection();
        await conn.OpenAsync();
        await using var tran = await conn.BeginTransactionAsync();

        try
        {
            var tranHelper = new SqlHelperWithTransaction(conn, tran, _connectionFactory.DbProvider, _logger, _retryPolicy, _redisCacheHelper);
            await transactionalOperations(tranHelper);
            await tran.CommitAsync();
        }
        catch (Exception ex)
        {
            await tran.RollbackAsync();
            _logger?.LogError(ex, "Transaction failed.");
            throw;
        }
    }

    public Task<string> BuildPagedQuery(string baseSql, string orderBy, int pageIndex, int pageSize)
    {
        int offset = (pageIndex - 1) * pageSize;
        string pagedSql = _connectionFactory.DbProvider.ToLower() switch
        {
            "mysql" => $"{baseSql} ORDER BY {orderBy} LIMIT {offset}, {pageSize}",
            "postgresql" => $"{baseSql} ORDER BY {orderBy} OFFSET {offset} LIMIT {pageSize}",
            _ => $"{baseSql} ORDER BY {orderBy} OFFSET {offset} ROWS FETCH NEXT {pageSize} ROWS ONLY"
        };
        return Task.FromResult(pagedSql);
    }

    public async Task<IEnumerable<T>> QueryCachedAsync<T>(string cacheKey, string sql, object? parameters = null, TimeSpan? expiry = null)
    {
        if (_redisCacheHelper == null)
            throw new InvalidOperationException("Redis cache helper not configured.");

        return await _redisCacheHelper.GetOrSetAsync(cacheKey, async () =>
        {
            await using var conn = GetConnection();
            await conn.OpenAsync();
            return await conn.QueryAsync<T>(sql, parameters);
        }, expiry);
    }

}

完整源码：【免费】.Net7封装操作数据库，支持MySql、MSSQL、postgresql多数据库操作资源-CSDN文库