告别Entity Framework臃肿：ASP.NET Core轻量级ORM之王Dapper实战指南-优快云博客

告别Entity Framework臃肿：ASP.NET Core轻量级ORM之王Dapper实战指南

【免费下载链接】aspnetcore dotnet/aspnetcore: 是一个 ASP.NET Core 应用程序开发框架的官方 GitHub 仓库，它包含了 ASP.NET Core 的核心源代码和技术文档。适合用于 ASP.NET Core 应用程序开发，特别是对于那些需要深入了解 ASP.NET Core 框架实现和技术的场景。特点是 ASP.NET Core 官方仓库、核心源代码、技术文档。项目地址: https://gitcode.com/GitHub_Trending/as/aspnetcore

你是否还在为Entity Framework的复杂配置和性能损耗而烦恼？作为.NET开发者，当你需要在ASP.NET Core项目中实现高效数据库操作时，轻量级ORM（对象关系映射，Object-Relational Mapping）工具Dapper或许是解决这些痛点的理想选择。本文将带你从零开始掌握Dapper的核心用法，通过实战案例展示如何在ASP.NET Core项目中集成Dapper，优化数据库访问性能，让你轻松应对从简单查询到复杂事务的各类场景。读完本文，你将能够：理解Dapper的核心优势，掌握Dapper在ASP.NET Core中的配置与使用方法，实现高效的数据查询、插入、更新和删除操作，处理复杂的多表关联查询，以及在实际项目中运用Dapper提升数据库操作性能。

Dapper简介与核心优势

Dapper是由Stack Overflow团队开发的一款轻量级ORM工具，它以高性能、简洁的API和低侵入性著称。与Entity Framework等全功能ORM框架相比，Dapper更接近原生SQL，同时又避免了手动编写大量ADO.NET代码的繁琐。

Dapper的核心优势主要体现在以下几个方面：

1. 卓越性能

Dapper采用了高效的对象映射机制，其性能接近手写的原生ADO.NET代码。根据官方测试和社区反馈，在大多数数据访问场景下，Dapper的性能要优于Entity Framework等重型ORM框架。这使得Dapper特别适合对性能要求较高的ASP.NET Core应用，尤其是在处理大量数据查询和高频数据库操作时，能够显著提升系统响应速度。

2. 简洁易用的API

Dapper的API设计非常简洁直观，主要通过扩展方法的形式为IDbConnection接口添加功能。开发者可以直接使用熟悉的SQL语句进行数据库操作，无需学习复杂的LINQ查询语法或ORM特定的查询规则。这种简洁性降低了学习成本，同时也使得代码更加易于理解和维护。

3. 低侵入性

Dapper不会对你的实体类施加过多限制，不需要像Entity Framework那样使用大量的特性（Attribute）或继承特定的基类。你可以直接使用普通的POCO（Plain Old CLR Object）类作为数据模型，这使得实体类更加纯净，与ORM框架的耦合度极低。这种低侵入性便于在现有项目中集成Dapper，也有利于代码的复用和测试。

4. 强大的SQL灵活性

使用Dapper，你可以完全控制SQL语句的编写。这意味着你可以根据具体业务需求编写复杂的SQL查询、存储过程调用等，充分利用数据库的高级特性。对于一些复杂的报表生成、数据统计分析等场景，Dapper能够让开发者更加灵活地优化SQL性能。

5. 广泛的数据库支持

Dapper支持多种数据库，包括SQL Server、MySQL、PostgreSQL、SQLite等常见的关系型数据库。这使得它在不同的项目环境中都能得到应用，具有很强的通用性。

ASP.NET Core项目中集成Dapper

要在ASP.NET Core项目中使用Dapper，首先需要进行必要的配置和依赖安装。以下是详细的步骤：

安装Dapper NuGet包

在ASP.NET Core项目中，你可以通过NuGet包管理器安装Dapper。打开项目的.csproj文件，添加对Dapper的引用，或者在NuGet包管理器控制台中执行以下命令：

Install-Package Dapper

或者使用.NET CLI：

dotnet add package Dapper

配置数据库连接字符串

在ASP.NET Core项目的appsettings.json文件中，添加数据库连接字符串。例如，对于SQL Server数据库，配置如下：

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=.;Database=YourDatabase;User Id=sa;Password=YourPassword;TrustServerCertificate=True"
  }
}

创建数据库连接服务

在Program.cs（或Startup.cs，取决于ASP.NET Core版本）中，注册数据库连接服务。你可以创建一个单例的IDbConnection实例，或者使用依赖注入的方式在需要时创建连接。以下是一种常见的做法，使用IServiceCollection的扩展方法来注册：

using Microsoft.Data.SqlClient;
using System.Data;

var builder = WebApplication.CreateBuilder(args);

// 添加数据库连接
builder.Services.AddScoped<IDbConnection>(sp => 
    new SqlConnection(builder.Configuration.GetConnectionString("DefaultConnection")));

// 其他服务配置...

var app = builder.Build();

// 应用中间件等...

app.Run();

这里使用了AddScoped方法，确保在每个请求范围内创建一个数据库连接实例，这样可以更好地管理连接的生命周期，避免连接泄漏。

Dapper核心操作实战

Dapper提供了一系列扩展方法来简化数据库操作，包括查询、插入、更新、删除等。以下将通过具体的代码示例展示这些核心操作。

查询数据（Query）

Dapper的Query方法用于执行查询并返回结果集。它支持将查询结果映射到实体类对象。

假设我们有一个Product实体类：

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int StockQuantity { get; set; }
}

以下是使用Dapper查询所有产品的示例：

using Dapper;
using Microsoft.AspNetCore.Mvc;
using System.Data;

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IDbConnection _dbConnection;

    public ProductsController(IDbConnection dbConnection)
    {
        _dbConnection = dbConnection;
    }

    [HttpGet]
    public async Task<IEnumerable<Product>> GetAllProducts()
    {
        string sql = "SELECT * FROM Products";
        return await _dbConnection.QueryAsync<Product>(sql);
    }

    [HttpGet("{id}")]
    public async Task<Product> GetProductById(int id)
    {
        string sql = "SELECT * FROM Products WHERE Id = @Id";
        return await _dbConnection.QueryFirstOrDefaultAsync<Product>(sql, new { Id = id });
    }
}

在上述代码中，QueryAsync<Product>方法执行SQL查询并将结果映射为Product类型的集合。QueryFirstOrDefaultAsync<Product>方法则返回查询结果中的第一个对象，如果没有找到则返回null。new { Id = id }是一个匿名对象，用于传递SQL参数，Dapper会自动将其映射到SQL语句中的@Id参数，有效防止SQL注入攻击。

插入数据（Execute）

使用Dapper的Execute方法可以执行插入、更新、删除等非查询SQL命令。以下是插入新产品的示例：

[HttpPost]
public async Task<IActionResult> CreateProduct(Product product)
{
    string sql = @"INSERT INTO Products (Name, Price, StockQuantity) 
                   VALUES (@Name, @Price, @StockQuantity);
                   SELECT CAST(SCOPE_IDENTITY() as int)";

    int newProductId = await _dbConnection.ExecuteScalarAsync<int>(sql, product);
    return CreatedAtAction(nameof(GetProductById), new { id = newProductId }, product);
}

这里使用了ExecuteScalarAsync<int>方法，它执行SQL语句并返回结果集中的第一行第一列的值，即新插入记录的ID。SQL语句中使用了参数化查询，product对象的属性会自动映射到@Name、@Price等参数。

更新数据

更新数据的操作与插入类似，同样使用Execute方法：

[HttpPut("{id}")]
public async Task<IActionResult> UpdateProduct(int id, Product product)
{
    if (id != product.Id)
    {
        return BadRequest();
    }

    string sql = @"UPDATE Products 
                   SET Name = @Name, Price = @Price, StockQuantity = @StockQuantity 
                   WHERE Id = @Id";

    int rowsAffected = await _dbConnection.ExecuteAsync(sql, product);
    if (rowsAffected == 0)
    {
        return NotFound();
    }

    return NoContent();
}

ExecuteAsync方法返回受影响的行数，通过判断行数可以确定更新操作是否成功。

删除数据

删除数据也是使用Execute方法：

[HttpDelete("{id}")]
public async Task<IActionResult> DeleteProduct(int id)
{
    string sql = "DELETE FROM Products WHERE Id = @Id";
    int rowsAffected = await _dbConnection.ExecuteAsync(sql, new { Id = id });
    if (rowsAffected == 0)
    {
        return NotFound();
    }

    return NoContent();
}

处理复杂查询与事务

Dapper不仅能处理简单的CRUD操作，还能轻松应对复杂查询和事务管理。

多表关联查询

对于多表关联查询，Dapper可以将结果映射到包含多个实体的复杂对象。例如，查询订单及其包含的订单项：

public class Order
{
    public int Id { get; set; }
    public DateTime OrderDate { get; set; }
    public string CustomerName { get; set; }
    public List<OrderItem> OrderItems { get; set; } = new List<OrderItem>();
}

public class OrderItem
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public int ProductId { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
}

[HttpGet("orders/{id}")]
public async Task<Order> GetOrderWithItems(int id)
{
    string sql = @"SELECT o.*, oi.* 
                   FROM Orders o
                   LEFT JOIN OrderItems oi ON o.Id = oi.OrderId
                   WHERE o.Id = @Id";

    var orderDictionary = new Dictionary<int, Order>();

    var orders = await _dbConnection.QueryAsync<Order, OrderItem, Order>(
        sql,
        (order, orderItem) =>
        {
            if (!orderDictionary.TryGetValue(order.Id, out var currentOrder))
            {
                currentOrder = order;
                orderDictionary.Add(currentOrder.Id, currentOrder);
            }

            if (orderItem != null)
            {
                currentOrder.OrderItems.Add(orderItem);
            }

            return currentOrder;
        },
        new { Id = id },
        splitOn: "Id");

    return orders.FirstOrDefault();
}

在这个例子中，使用了QueryAsync的多类型映射重载。splitOn: "Id"表示结果集将以Id列作为分隔点，将数据分别映射到Order和OrderItem对象。通过一个字典来合并同一个订单的多个订单项。

事务处理

Dapper支持使用事务来确保多个数据库操作的原子性。在ASP.NET Core中，可以通过IDbConnection的BeginTransaction方法开启事务：

[HttpPost("createorder")]
public async Task<IActionResult> CreateOrderWithItems(Order order)
{
    using (var transaction = await _dbConnection.BeginTransactionAsync())
    {
        try
        {
            // 插入订单
            string orderSql = @"INSERT INTO Orders (OrderDate, CustomerName) 
                                VALUES (@OrderDate, @CustomerName);
                                SELECT CAST(SCOPE_IDENTITY() as int)";
            int orderId = await _dbConnection.ExecuteScalarAsync<int>(orderSql, order, transaction);

            // 插入订单项
            string orderItemSql = @"INSERT INTO OrderItems (OrderId, ProductId, Quantity, UnitPrice) 
                                   VALUES (@OrderId, @ProductId, @Quantity, @UnitPrice)";
            foreach (var item in order.OrderItems)
            {
                item.OrderId = orderId;
                await _dbConnection.ExecuteAsync(orderItemSql, item, transaction);
            }

            transaction.Commit();
            return CreatedAtAction(nameof(GetOrderWithItems), new { id = orderId }, order);
        }
        catch
        {
            transaction.Rollback();
            throw;
        }
    }
}

在上述代码中，BeginTransactionAsync方法开启一个异步事务。所有的数据库操作都指定了该事务对象，确保它们在同一个事务上下文中执行。如果所有操作成功，则提交事务；如果发生异常，则回滚事务，保证数据的一致性。

Dapper与其他ORM的对比及适用场景

ORM框架	优势	劣势	适用场景
Dapper	性能卓越、API简洁、SQL控制力强、轻量级、学习成本低	需手动编写SQL、不支持自动迁移、复杂查询需较多代码	性能要求高的系统、复杂SQL查询场景、已有成熟SQL脚本的项目、对ORM侵入性敏感的项目
Entity Framework Core	自动化程度高、支持LINQ查询、内置迁移工具、面向对象设计友好	性能相对较低、复杂查询调试困难、配置复杂	快速开发、中小型项目、团队熟悉LINQ、对SQL编写能力要求不高的场景
NHibernate	功能全面、成熟稳定、跨数据库支持好	配置复杂、学习曲线陡峭、性能一般	大型企业级应用、需要严格遵循ORM规范的项目

通过以上对比可以看出，Dapper在性能和SQL控制力方面具有明显优势，适合那些对性能要求苛刻、需要灵活编写SQL的ASP.NET Core项目。而Entity Framework Core等全功能ORM框架则更适合快速开发和对SQL编写不太熟悉的团队。

总结与最佳实践

Dapper作为一款轻量级ORM工具，为ASP.NET Core项目提供了高效、灵活的数据库访问方案。通过本文的介绍，你应该已经掌握了Dapper的核心用法，包括在ASP.NET Core中的集成、基本CRUD操作、复杂查询和事务处理等。

以下是一些使用Dapper的最佳实践：

始终使用参数化查询：Dapper的参数化查询可以有效防止SQL注入攻击，确保应用安全。
合理管理连接生命周期：使用依赖注入（如本文示例中的AddScoped）来管理IDbConnection的生命周期，避免连接泄漏。
优化SQL语句：充分利用Dapper对SQL的控制力，编写高效的SQL查询，避免N+1查询等性能问题。
使用异步方法：优先使用Dapper的异步方法（如QueryAsync、ExecuteAsync等），以提高ASP.NET Core应用的并发处理能力。
处理大数据集：对于返回大量数据的查询，可以考虑使用QueryAsync的分页功能，或者使用IDbDataReader进行流式读取。
结合存储过程：对于复杂的业务逻辑，可以将SQL代码编写为存储过程，然后使用Dapper调用，提高代码的可维护性。

通过合理运用Dapper，你可以在ASP.NET Core项目中实现高效、灵活的数据库操作，告别重型ORM带来的性能瓶颈和复杂性，让你的应用跑得更快、更稳定。

希望本文对你在ASP.NET Core项目中使用Dapper有所帮助。如果你有任何问题或建议，欢迎在评论区留言讨论。别忘了点赞、收藏本文，关注我们获取更多ASP.NET Core开发技巧和最佳实践！

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考