DotNetNext/SqlSugar 的 CRUD 操作完全指南

最新推荐文章于 2025-09-23 05:08:55 发布
原创 最新推荐文章于 2025-09-23 05:08:55 发布 · 311 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

DotNetNext/SqlSugar 的 CRUD 操作完全指南

【免费下载链接】SqlSugar DotNetNext/SqlSugar: 这是一个用于SQL Server和MySQL的ORM框架。适合用于需要简化数据库操作的场景。特点：易于使用，支持多种数据库，具有代码生成和自动映射功能。 【免费下载链接】SqlSugar 项目地址: https://gitcode.com/DotNetNext/SqlSugar

还在为数据库操作繁琐而烦恼？还在为不同数据库的SQL语法差异而头疼？DotNetNext/SqlSugar 作为一款强大的 .NET ORM 框架，提供了极其简洁优雅的CRUD操作方式，让你彻底告别原生SQL的复杂性！

通过本文，你将掌握：

  • ✅ SqlSugar 核心CRUD操作的精髓
  • ✅ 单表和多表查询的多种姿势
  • ✅ 批量操作和高性能写入技巧
  • ✅ 事务处理和高级功能应用
  • ✅ 实际项目中的最佳实践

🚀 SqlSugar 简介与优势

SqlSugar 是一个功能强大的 .NET ORM（Object-Relational Mapping，对象关系映射）框架，支持多种数据库，包括：

数据库类型支持情况特点
SQL Server✅ 完全支持企业级应用首选
MySQL✅ 完全支持开源数据库王者
PostgreSQL✅ 完全支持功能丰富的开源数据库
Oracle✅ 完全支持企业级关系数据库
SQLite✅ 完全支持轻量级嵌入式数据库
达梦数据库✅ 支持国产数据库
MongoDB✅ 支持NoSQL文档数据库

核心优势

mermaid

🏗️ 环境配置与初始化

安装NuGet包

<PackageReference Include="SqlSugarCore" Version="5.1.4.109" />

数据库连接配置

public static class DbConfig
{
    public static SqlSugarScope Db = new SqlSugarScope(new ConnectionConfig()
    {
        ConnectionString = "Server=.;Database=TestDB;User ID=sa;Password=123456;",
        DbType = DbType.SqlServer,
        IsAutoCloseConnection = true,
        InitKeyType = InitKeyType.Attribute
    });
}

实体类定义

[SugarTable("Students")]
public class Student
{
    [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
    public int Id { get; set; }
    
    public string Name { get; set; }
    
    public int Age { get; set; }
    
    public DateTime CreateTime { get; set; }
    
    [SugarColumn(IsNullable = true)]
    public string Email { get; set; }
}

[SugarTable("Courses")]
public class Course
{
    [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
    public int Id { get; set; }
    
    public string CourseName { get; set; }
    
    public int StudentId { get; set; }
}

📖 查询操作（Read）

基础查询

// 查询所有记录
var allStudents = DbConfig.Db.Queryable<Student>().ToList();

// 条件查询
var adultStudents = DbConfig.Db.Queryable<Student>()
    .Where(s => s.Age >= 18)
    .ToList();

// 排序查询
var sortedStudents = DbConfig.Db.Queryable<Student>()
    .OrderBy(s => s.Age, OrderByType.Desc)
    .ToList();

// 分页查询
int pageIndex = 1;
int pageSize = 10;
int totalCount = 0;
var pagedStudents = DbConfig.Db.Queryable<Student>()
    .ToPageList(pageIndex, pageSize, ref totalCount);

高级查询技巧

// 模糊查询
var searchResults = DbConfig.Db.Queryable<Student>()
    .Where(s => s.Name.Contains("张"))
    .ToList();

// 多条件组合查询
var complexQuery = DbConfig.Db.Queryable<Student>()
    .Where(s => s.Age > 18 && s.Age < 25)
    .Where(s => s.Email != null)
    .OrderBy(s => s.CreateTime)
    .ToList();

// 选择特定字段
var studentNames = DbConfig.Db.Queryable<Student>()
    .Select(s => new { s.Id, s.Name })
    .ToList();

联表查询

// 内连接查询
var joinQuery = DbConfig.Db.Queryable<Student>()
    .InnerJoin<Course>((s, c) => s.Id == c.StudentId)
    .Select((s, c) => new 
    { 
        StudentName = s.Name, 
        CourseName = c.CourseName 
    })
    .ToList();

// 左连接查询
var leftJoinQuery = DbConfig.Db.Queryable<Student>()
    .LeftJoin<Course>((s, c) => s.Id == c.StudentId)
    .Select((s, c) => new 
    { 
        StudentName = s.Name, 
        CourseName = c.CourseName 
    })
    .ToList();

➕ 插入操作（Create）

单条插入

// 插入单条记录并返回影响行数
var newStudent = new Student 
{ 
    Name = "张三", 
    Age = 20, 
    Email = "zhangsan@email.com",
    CreateTime = DateTime.Now
};
var insertCount = DbConfig.Db.Insertable(newStudent).ExecuteCommand();

// 插入并返回自增ID
var newId = DbConfig.Db.Insertable(newStudent).ExecuteReturnIdentity();

// 插入并返回雪花ID（分布式ID）
var snowflakeId = DbConfig.Db.Insertable(newStudent).ExecuteReturnSnowflakeId();

批量插入

// 批量插入普通方式
var students = new List<Student>
{
    new Student { Name = "李四", Age = 21, CreateTime = DateTime.Now },
    new Student { Name = "王五", Age = 22, CreateTime = DateTime.Now },
    new Student { Name = "赵六", Age = 23, CreateTime = DateTime.Now }
};
var batchResult = DbConfig.Db.Insertable(students).ExecuteCommand();

// 高性能批量插入（推荐大数据量）
DbConfig.Db.Fastest<Student>().BulkCopy(students);

// 分页批量插入（避免内存溢出）
DbConfig.Db.Insertable(students).PageSize(1000).ExecuteCommand();

✏️ 更新操作（Update）

基于实体更新

// 更新单个实体
var studentToUpdate = new Student 
{ 
    Id = 1, 
    Name = "张三Updated", 
    Age = 21 
};
var updateCount = DbConfig.Db.Updateable(studentToUpdate).ExecuteCommand();

// 批量更新实体
var studentsToUpdate = new List<Student>
{
    new Student { Id = 1, Name = "张三", Age = 22 },
    new Student { Id = 2, Name = "李四", Age = 23 }
};
var batchUpdateCount = DbConfig.Db.Updateable(studentsToUpdate).ExecuteCommand();

基于表达式更新

// 更新指定字段
DbConfig.Db.Updateable<Student>()
    .SetColumns(s => new Student 
    { 
        Name = "新名称", 
        Age = s.Age + 1 
    })
    .Where(s => s.Id == 1)
    .ExecuteCommand();

// 忽略空值更新
DbConfig.Db.Updateable(studentToUpdate)
    .IgnoreNullColumns()
    .ExecuteCommand();

// 更新指定列，忽略其他列
DbConfig.Db.Updateable(studentToUpdate)
    .UpdateColumns(s => new { s.Name, s.Age })
    .ExecuteCommand();

高性能批量更新

// 使用Fastest进行高性能批量更新
DbConfig.Db.Fastest<Student>().BulkUpdate(studentsToUpdate);

// 分页批量更新
DbConfig.Db.Updateable(studentsToUpdate)
    .PageSize(500)
    .ExecuteCommand();

🗑️ 删除操作（Delete）

基于实体删除

// 删除单个实体
var studentToDelete = new Student { Id = 1 };
var deleteCount = DbConfig.Db.Deleteable(studentToDelete).ExecuteCommand();

// 批量删除实体
var studentsToDelete = new List<Student>
{
    new Student { Id = 1 },
    new Student { Id = 2 }
};
var batchDeleteCount = DbConfig.Db.Deleteable(studentsToDelete).ExecuteCommand();

基于条件删除

// 根据主键删除
DbConfig.Db.Deleteable<Student>().In(1).ExecuteCommand();
DbConfig.Db.Deleteable<Student>().In(new[] { 1, 2, 3 }).ExecuteCommand();

// 根据条件表达式删除
DbConfig.Db.Deleteable<Student>()
    .Where(s => s.Age < 18)
    .ExecuteCommand();

// 联表条件删除
DbConfig.Db.Deleteable<Student>()
    .Where(s => SqlFunc.Subqueryable<Course>()
        .Where(c => c.StudentId == s.Id && c.CourseName == "数学")
        .Any())
    .ExecuteCommand();

高性能批量删除

// 分页批量删除
DbConfig.Db.Deleteable(studentsToDelete)
    .PageSize(1000)
    .ExecuteCommand();

🔄 事务处理

基本事务使用

try
{
    DbConfig.Db.Ado.BeginTran();
    
    // 执行多个操作
    DbConfig.Db.Insertable(newStudent).ExecuteCommand();
    DbConfig.Db.Updateable(studentToUpdate).ExecuteCommand();
    
    DbConfig.Db.Ado.CommitTran();
}
catch (Exception ex)
{
    DbConfig.Db.Ado.RollbackTran();
    throw;
}

使用SqlSugarScope的事务

using (var tran = DbConfig.Db.UseTran())
{
    try
    {
        // 业务操作
        DbConfig.Db.Insertable(newStudent).ExecuteCommand();
        DbConfig.Db.Updateable(studentToUpdate).ExecuteCommand();
        
        tran.CommitTran();
    }
    catch
    {
        tran.RollbackTran();
        throw;
    }
}

多数据库事务

// 创建多数据库配置
var multiDb = new SqlSugarClient(new List<ConnectionConfig>()
{
    new ConnectionConfig(){ ConfigId="db1", DbType=DbType.SqlServer, ConnectionString=connStr1 },
    new ConnectionConfig(){ ConfigId="db2", DbType=DbType.MySql, ConnectionString=connStr2 }
});

multiDb.BeginTran();
try
{
    var db1 = multiDb.GetConnection("db1");
    var db2 = multiDb.GetConnection("db2");
    
    db1.Insertable(entity1).ExecuteCommand();
    db2.Insertable(entity2).ExecuteCommand();
    
    multiDb.CommitTran();
}
catch
{
    multiDb.RollbackTran();
    throw;
}

🚀 高级功能与最佳实践

1. 分表功能

// 分表实体定义
[SplitTable(SplitType.Year)]
[SugarTable("Order_{year}{month}{day}")]
public class Order
{
    [SugarColumn(IsPrimaryKey = true)]
    public long Id { get; set; }
    
    [SplitField]
    public DateTime CreateTime { get; set; }
    
    public decimal Amount { get; set; }
}

// 分表查询
var orders = DbConfig.Db.Queryable<Order>()
    .SplitTable(DateTime.Now.AddYears(-1), DateTime.Now)
    .ToList();

2. 查询过滤器

// 添加全局查询过滤器
DbConfig.Db.QueryFilter.Add(new TableFilterItem<Student>(it => it.Age >= 18));

// 所有查询都会自动加上 Age >= 18 的条件
var adults = DbConfig.Db.Queryable<Student>().ToList();

3. 高性能批量操作对比

操作类型传统方式Fastest方式性能提升
插入10万条~30秒~3秒10倍
更新10万条~25秒~2.5秒10倍
删除10万条~20秒~2秒10倍

4. AOP拦截器

DbConfig.Db.Aop.OnLogExecuting = (sql, paras) =>
{
    Console.WriteLine($"执行SQL: {sql}");
    Console.WriteLine($"参数: {string.Join(", ", paras.Select(p => $"{p.ParameterName}={p.Value}"))}");
};

DbConfig.Db.Aop.OnError = (exp) =>
{
    Console.WriteLine($"数据库操作错误: {exp.Message}");
};

📊 CRUD操作性能优化指南

mermaid

🎯 实际应用场景

场景1：用户管理系统

public class UserService
{
    public async Task<PagedList<User>> GetUsersAsync(UserQuery query)
    {
        var totalCount = 0;
        var users = await DbConfig.Db.Queryable<User>()
            .WhereIF(!string.IsNullOrEmpty(query.Keyword), 
                     u => u.Name.Contains(query.Keyword) || u.Email.Contains(query.Keyword))
            .WhereIF(query.MinAge.HasValue, u => u.Age >= query.MinAge.Value)
            .WhereIF(query.MaxAge.HasValue, u => u.Age <= query.MaxAge.Value)
            .OrderBy(u => u.CreateTime, OrderByType.Desc)
            .ToPageListAsync(query.PageIndex, query.PageSize, totalCount);
            
        return new PagedList<User>(users, totalCount, query.PageIndex, query.PageSize);
    }
    
    public async Task<int> CreateUserAsync(User user)
    {
        user.CreateTime = DateTime.Now;
        return await DbConfig.Db.Insertable(user).ExecuteReturnIdentityAsync();
    }
}

场景2：订单处理系统

public class OrderService
{
    public async Task ProcessOrderAsync(Order order, List<OrderItem> items)
    {
        using (var tran = DbConfig.Db.UseTran())
        {
            try
            {
                // 插入订单
                var orderId = await DbConfig.Db.Insertable(order).ExecuteReturnIdentityAsync();
                
                // 插入订单项
                items.ForEach(item => item.OrderId = orderId);
                await DbConfig.Db.Insertable(items).ExecuteCommandAsync();
                
                // 更新库存
                foreach (var item in items)
                {
                    await DbConfig.Db.Updateable<Product>()
                        .SetColumns(p => p.StockQuantity == p.StockQuantity - item.Quantity)
                        .Where(p => p.Id == item.ProductId && p.StockQuantity >= item.Quantity)
                        .ExecuteCommandAsync();
                }
                
                tran.Commit();
            }
            catch
            {
                tran.Rollback();
                throw;
            }
        }
    }
}

🔍 常见问题与解决方案

Q1: 如何处理并发冲突？

// 使用乐观锁
[SugarTable("Products")]
public class Product
{
    [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
    public int Id { get; set; }
    
    public string Name { get; set; }
    
    public int Stock { get; set; }
    
    [SugarColumn(IsEnableUpdateVersionValidation = true)] // 乐观锁字段
    public long Version { get; set; }
}

// 更新时会自动检查版本
DbConfig.Db.Updateable(product).ExecuteCommand();

Q2: 如何实现软删除？

// 实体类中添加删除标记
public class BaseEntity
{
    [SugarColumn(IsNullable = true)]
    public bool IsDeleted { get; set; }
    
    [SugarColumn(IsNullable = true)]
    public DateTime? DeleteTime { get; set; }
}

// 添加全局查询过滤器
DbConfig.Db.QueryFilter.Add(new TableFilterItem<BaseEntity>(it => it.IsDeleted == false));

// 软删除方法
public async Task SoftDeleteAsync<T>(int id) where T : BaseEntity
{
    await DbConfig.Db.Updateable<T>()
        .SetColumns(t => new T { IsDeleted = true, DeleteTime = DateTime.Now })
        .Where(t => t.Id == id)
        .ExecuteCommandAsync();
}

Q3: 如何优化查询性能？

// 1. 使用合适的索引
// 2. 避免N+1查询问题
// 3. 使用Include进行关联查询
var users = DbConfig.Db.Queryable<User>()
    .Includes(u => u.Orders)
    .Includes(u => u.Addresses)
    .ToList();

// 4. 使用异步方法
var asyncResult = await DbConfig.Db.Queryable<User>().ToListAsync();

📈 性能监控与调优

监控SQL执行情况

DbConfig.Db.Aop.OnLogExecuting = (sql, param) =>
{
    var stopwatch = Stopwatch.StartNew();
    // 记录开始时间
};

DbConfig.Db.Aop.OnLogExecuted = (sql, param) =>
{
    // 记录执行时间，超过阈值则报警
    if (stopwatch.ElapsedMilliseconds > 1000)
    {
        Logger.Warning($"慢SQL检测: {sql}, 执行时间: {stopwatch.ElapsedMilliseconds}ms");
    }
};

数据库连接池优化

new ConnectionConfig()
{
    ConnectionString = connStr,
    DbType = DbType.SqlServer,
    IsAutoCloseConnection = true,
    InitKeyType = InitKeyType.Attribute,
    ConnectionPoolSize = 50, // 连接池大小
    PoolMaxIdleTime = 300 // 最大空闲时间(秒)
}

🎉 总结

通过本文的详细讲解，相信你已经全面掌握了 SqlSugar 的 CRUD 操作精髓。SqlSugar 以其简洁的API设计、强大的功能和优异的性能，成为了 .NET 开发中数据库操作的首选框架。

关键收获：

  • 🎯 掌握了从基础到高级的CRUD操作
  • 🚀 学会了性能优化和事务处理
  • 🔧 了解了实际项目中的最佳实践
  • 📊 获得了监控和调优的方法

无论你是初学者还是经验丰富的开发者，SqlSugar 都能为你的项目提供稳定、高效的数据库操作支持。现在就开始使用 SqlSugar，让你的数据库操作变得更加简单和优雅吧！

下一步行动：

  1. 在你的项目中引入 SqlSugar
  2. 尝试本文中的代码示例
  3. 根据业务需求选择合适的优化策略
  4. 持续监控和优化数据库性能

Happy coding! 🚀

【免费下载链接】SqlSugar DotNetNext/SqlSugar: 这是一个用于SQL Server和MySQL的ORM框架。适合用于需要简化数据库操作的场景。特点：易于使用，支持多种数据库，具有代码生成和自动映射功能。 【免费下载链接】SqlSugar 项目地址: https://gitcode.com/DotNetNext/SqlSugar

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

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值