.NET ORM开发手册：基于SqlSugar的高效数据访问全攻略

SqlSuger是一个国产，开源ORM框架，具有高性能，使用方便，功能全面的特点，支持.NET Framework和.NET Core，支持各种关系型数据库，分布式数据库，时序数据库。

官网地址：SqlSugar .Net ORM 5.X 官网 、文档、教程 - SqlSugar 5x - .NET果糖网

基础知识

1、在Nuget中搜索 SqlSugarCore安装.NET Core版本，搜索SqlSugar安装.NET Framework版本。

2、它有两种对象SqlSugarClient和SqlSugarScope访问数据库，SqlSugarClient等同于在ADO，EF，Dapper中所使用的数据库访问对象，每次请求new一个新对象，db禁止跨上下文使用，IOC建议用Scope或者瞬发注入。

以下是连接数据库，并检验是否连接成功的Demo

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {var flag = db.Ado.IsValidConnection();  //如果时间长，可以在连接字符串配置 连接超时时间Console.WriteLine(flag == true ? "连接成功" : "连接失败");});

DBFirst

DBFirst即数据库优先模式，它指的是先生成数据库，再生成实体类，SqlSuger可以根据表的结构自动生成实体类文件。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {});// 生成student实体类，放在桌面的Models文件夹下，命名空间是XCYN.NET8.Print.ModelsDb.DbFirst.Where("student").CreateClassFile("C:\\Users\\Administrator\\Desktop\\Models", "XCYN.NET8.Print.Models");

运行完代码后，会在指定文件夹下生成一个cs文件，将它复制到项目中即可。

接着使用这个类进行查询操作

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 查询student表中id为1的集合var result = Db.Queryable<student>().Where(it => it.id == "1").ToList();result.ForEach(m => {Console.WriteLine(m.Name.ToString());});

查询完毕后，还可以在OnLogExecuting委托中打印SQL，方便我们进行SQL优化。

CodeFirst

CodeFirst和DBFirst相比更加灵活，假如需要更换数据库，采用这种方式会自动创建数据表，而且这种方式更符合面向对象的思想。

1、创建一个实体类

    public class School{[SugarColumn(IsIdentity = true, IsPrimaryKey = true)]public int Id { get; set; }public string Name { get; set; }//ColumnDataType 一般用于单个库数据库，如果多库不建议用[SugarColumn(ColumnDataType = "Nvarchar(255)")]public string Text { get; set; }[SugarColumn(IsNullable = true)]//可以为NULLpublic DateTime CreateTime { get; set; }}

2、创建数据表

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 创建指定的表，字符串类型默认长度200Db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(School));

索引

索引可以加快数据查询的速度，在经常查询的字段上建立索引可以有效地提高查询效率。

按数量划分

1、单列索引

单列索引有可以细分为唯一索引，主键索引，普通索引

唯一索引的值不能重复，只能是唯一的

主键索引是特殊的唯一索引，表的主键拥有主键索引，主键索引不能有空值

普通索引即不是唯一的，也非主键

2、多列索引

多列索引又可被称为：组合索引，联合索引，复合索引，多值索引

将多个字段联合起来建立的索引称之为多列索引。

按功能划分

1、唯一索引

2、主键索引

3、普通索引

4、全文索引

全文索引类似于在Word中按照关键字进行检索

5、空间索引

空间索引常用于空间坐标的场合，比如地图中

按存储方式划分

1、聚集索引

聚集索引指的是在磁盘上按照逻辑顺序存放的索引，一般会将主键索引当做聚集索引

2、非聚集索引

非聚集索引指的是在磁盘上没有按照逻辑顺序存放的索引

通过执行计划分析SQL语句执行的效率

在SQL语句中使用Explain查看执行计划时，type列会显示此次查询走的是哪种索引

ALL：全表扫描，即没有走索引，需要优化

Const：通过主键或唯一索引命中的查询，仅匹配一条

Ref：通过普通索引命中的查询，可匹配多条

Eq-Ref：多表关联查询时，通过主键或唯一索引命中的查询

System：表中仅有一条数据，直接从内存中读取，如查询系统表的时间

Range：通过索引进行范围查询，如Between，>，In

Index：查询了包含索引的字段，但没加筛选条件

效率排行：System > Const > Eq-Ref > Ref > Range > Index > ALL

建议至少达到Range级别，尽量优化到Ref或Eq-Ref

在SqlSuger中，同样可以使用特性来创建索引：

    // 普通索引（可以写多个）[SugarIndex("index_School_name", nameof(School.Name), OrderByType.Asc)]// 唯一索引 (true表示唯一索引 或者叫 唯一约束)// [SugarIndex("unique_School_CreateTime", nameof(School.CreateTime), OrderByType.Desc, true)]public class School{[SugarColumn(IsIdentity = true, IsPrimaryKey = true)]public int Id { get; set; }public string Name { get; set; }//ColumnDataType 一般用于单个库数据库，如果多库不建议用[SugarColumn(ColumnDataType = "Nvarchar(255)")]public string Text { get; set; }[SugarColumn(IsNullable = true)]//可以为NULLpublic DateTime CreateTime { get; set; }}

给类添加SugarIndex特性，并依次设置：索引名称，字段名称，排序方式，就可以在创建表的同时设置索引，它支持唯一索引，普通索引，以及复合索引

插入数据

添加数据时需要调用Insertable方法，并传入一个实例对象。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 插入单条数据School model = new School(){Name = "张三",Text = "测试数据",CreateTime = DateTime.Now};// Db.Insertable<School>(model).ExecuteCommand();// 返回自增列var id = Db.Insertable(model).ExecuteReturnIdentity();Console.WriteLine(id);
}

由于Id是自增的，所以不用指定，还可以返回自增Id。

在分布式的场景下，使用自增Id会面临在多台数据库里出现重复Id的现象，常用的解决方案是使用Guid，即一个绝对不会重复的字符串，但这种方式也有问题，就是在聚集索引里无法排序，这时可以使用雪花ID，它是由时间戳，机器ID，自定义ID组成，既能满足不会重复的要求，也可以排序。

批量插入和单条类似，都是调用Insertable方法，不同的是传入的是一个集合，如果数据量大可以使用Fastest方法，效率更高。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456;AllowLoadLocalInfile=true;",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});List<School> list = new List<School>();for (int i = 0; i < 10000; i++){// 插入单条数据School model = new School(){Name = "张三",Text = "测试数据：" + i.ToString(),CreateTime = DateTime.Now};list.Add(model);}// Db.Insertable(list).ExecuteCommand();Db.Fastest<School>().PageSize(10000).BulkCopy(list); //MySql连接字符串要加AllowLoadLocalInfile=true

修改数据

修改数据时调用Updateable方法，不过如果只调用它会将没有传入的值的默认值更新到数据库中，解决方法有两个：给不希望更新的字段设置特性SugerColumn的IsOnlyIgnoreUpdate属性设置为true；或者创建一个跟踪器。

1、给不希望更新的字段设置特性SugerColumn的IsOnlyIgnoreUpdate属性设置为true

    [SugarColumn(IsNullable = true, IsOnlyIgnoreUpdate = true)]//可以为NULL，忽略更新public DateTime CreateTime { get; set; }

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 只更新修改了的字段，不会修改其他字段School model = new School(){Id = 1,};model.Name = "王五";model.Text = "测试数据";Db.Updateable(model).ExecuteCommand();

这样就不会更新CreateTime字段了

2、创建一个跟踪器

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 只更新修改了的字段，不会修改其他字段School model = new School(){Id = 1,};// 创建跟踪Db.Tracking(model);model.Name = "王五";model.Text = "测试数据";Db.Updateable(model).ExecuteCommand();Db.ClearTracking();

跟踪器的原理是通过反射获取这个对象哪些字段的值发生了改变，然后将这些字段拼接为SQL。

依据非主键的字段进行更新

这种需求也很常见，毕竟主键只有一个，而更新的依据会由很多种。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 只更新修改了的字段，不会修改其他字段School model = new School(){Name = "李四"};// 创建跟踪Db.Tracking(model);model.Text = "测试数据2";Db.Updateable(model).WhereColumns(m => m.Name).ExecuteCommand();Db.ClearTracking();

新增或修改

在表单与列表共存的管理界面中，通常需要同时支持数据新增和修改功能。其业务逻辑可抽象为：当用户提交数据时，系统需自动判断数据记录是否存在——若存在则执行更新操作，不存在则执行新增操作。借助SqlSugar ORM框架，该通用逻辑已被封装为Storageable方法，开发者可直接调用实现"存在即更新，不存在即插入"的智能化存储策略。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 修改或更新数据，首先依据Id查询是否存在，如果不存在则新增，如果存在则修改School model = new School(){Id = 2,Name = "李四",Text = "测试数据",CreateTime = DateTime.Now};Db.Storageable(model).ExecuteCommand();

删除数据

删除单条数据，多条数据，依据非主键字段删除数据

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 删除单条数据Db.Deleteable<School>(new School() { Id = 1 }).ExecuteCommand();// 删除多条数据Db.Deleteable<School>(new List<School>() { new School() { Id = 2},new School() {Id = 3},}).ExecuteCommand();// 依据非主键字段删除数据Db.Deleteable<School>().WhereColumns(new List<School>() { new School() { Text = "测试数据：3",},new School() {Text = "测试数据：4",},}, m => new { m.Text }).ExecuteCommand();

逻辑删除

有时候我们希望数据能一直存在于数据库中，这样方便回滚数据，追溯数据。这时会用到逻辑删除，只对某个字段的值进行修改，SqlSuger中支持这种方式，默认将IsDelete看做是逻辑删除的字段。

    [SugarColumn(IsNullable = true, DefaultValue = "0")]public bool IsDelete { get; set; }

使用CodeFirst将字段更新到数据库中后，并将值设置为0，0表示未删除。使用逻辑删除需要用到IsLogic方法。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// Db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(School));// 逻辑删除数据Db.Deleteable<School>(new School() { Id = 6 }).IsLogic().ExecuteCommand();

也支持自定义字段，在ExecuteCommand方法中传入字段的名字即可，还可以指定更新时间，操作人。

自定义逻辑删除字段，更新时间和操作人

首先将更新时间和操作人字段添加到数据库中，这里也将自定义删除标记字段添加进去。

    [SugarColumn(IsNullable = true, DefaultValue = "0")]public bool is_delete { get; set; }[SugarColumn(IsNullable = true)]public DateTime? UpdateTime { get; set; }[SugarColumn(IsNullable = true)]public string? ModifierName { get; set; }

逻辑删除数据，并指定更新时间和操作人，自定义的删除标记字段。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// Db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(School));// 逻辑删除数据Db.Deleteable<School>(new School() { Id = 8 }).IsLogic().ExecuteCommand("is_delete", true, "UpdateTime", "ModifierName", "04");

查询数据

基础查询

基础查询时要调用Queryable方法，后续再跟一个Linq的扩展方法，比如：Where，Count，Contains，Any，OrderBy，SingleOrDefault，FirstOrDefault等，它们对应不同的SQL语句像是：Where，Count，In，Like，OrderBy，<>，is null等等。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 全表查询var list = Db.Queryable<School>().ToList();list.ForEach(m => {Console.WriteLine(m);});// 查询总数var count = Db.Queryable<School>().Count();Console.WriteLine("Count="+count);// 按条件查询var list2 = Db.Queryable<School>().Where(m => m.Id == 1).ToList();list2.ForEach(m => {Console.WriteLine(m);});// In查询int[] ids = new int[] { 1, 2, 3 };var list3 = Db.Queryable<School>().Where(m => ids.Contains(m.Id)).ToList();list3.ForEach(m => {Console.WriteLine(m);});// In查询（多个字段）List<School> ids2 = new List<School>(){new School(){Id = 1,Name = "张三"},new School(){Id = 2,Name = "李四"},};var list4 = Db.Queryable<School>().Where(m => ids2.Any(n =>m.Id == n.Id && m.Name == n.Name )).ToList();list4.ForEach(m => {Console.WriteLine(m);});// 模糊查询var list5 = Db.Queryable<School>().Where(m => m.Name.Contains("张")).ToList();list5.ForEach(m => {Console.WriteLine(m);});// 排序var list6 = Db.Queryable<School>().OrderBy(m => m.Id).ToList();Console.WriteLine("--------------正序--------------");list6.ForEach(m => {Console.WriteLine(m);});// 倒序list6 = Db.Queryable<School>().OrderBy(m => m.Id, OrderByType.Desc).ToList();Console.WriteLine("--------------倒序--------------");list6.ForEach(m => {Console.WriteLine(m);});

扩展：

SingleOrDefault与FirstOrDefault有什么区别？

SingleOrDefault是查询结果只有一条时才正常返回结果，否则抛异常。

FirstOrDefault是在有单条或多条的结果时，返回第一条。

分页查询

分页查询是经常会用到的场景，调用ToPageList方法，并传入当前页码，每页条数即可。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取原生SQL推荐 5.1.4.63  性能OK//  Console.WriteLine(UtilMethods.GetNativeSql(sql, pars));//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});var count = 0;var totalPage = 0;for (int i = 1; i < 100; i++){var index = i;var size = 10;var list = Db.Queryable<School>().ToPageList(index, size, ref count, ref totalPage);list.ForEach(m => {Console.WriteLine(m.ToString());});}Console.WriteLine($"合计：{count}条，{totalPage}页");

使用Count统计数据时，由于是全表扫描所以耗时很长，当数据大于1个亿的时候需要约1分钟，这时可以在MySQL的Schema中查询表的行数，但这种方法不是很准确

SELECT table_rows FROM Information_Schema.`TABLES`

WHERE table_Schema = 'mes' AND TABLE_NAME = 'school'

还有一种方法是通过缓存技术去实现，比如定时读取表的行数后更新到缓存中，只有当数据增加或删除时才会查询总行数，其他操作都只从缓存中读取。

分组和去重

分组是数据库的常见操作，在统计数据时经常会用到，就好比上学的时候会分班，就是以班级名称为分组依据，比如要统计每个班级里男生和女生的数量时，就是求各个班级的性别的Count值；或者期末时统计考试成绩的平均数时，就是对分数字段求Avg值。

在SqlSuger中使用GroupBy方法并配合Select实现分组查询。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取原生SQL推荐 5.1.4.63  性能OK//  Console.WriteLine(UtilMethods.GetNativeSql(sql, pars));//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 以CreateTime分组，显示每组Id的数量var list = Db.Queryable<School>().GroupBy(m => m.CreateTime).Select(m => new{CreateTime = m.CreateTime,Count = SqlFunc.AggregateCount(m.Id),}).OrderBy(m => m.CreateTime).ToList();list.ForEach(m => {Console.WriteLine(m.ToString());});// 去重，去重方法得和Select一起使用，因为主键不可能重复，只能去指定其他可以重复的字段，这里指定的是Textvar count1 = Db.Queryable<School>().Distinct().Select(m => m.Text).Count();var count2 = Db.Queryable<School>().Select(m => m.Text).Count();Console.WriteLine($"去重前：{count1}");Console.WriteLine($"去重后：{count2}");

SqlFunc是SqlSuger的开窗函数，比如：SqlFunc.AggregateCount()具有汇总的作用。

去重操作的方法和SQL里的一致都是Distinct方法，也要与Select配合使用。

联表查询

一张表往往不足以包含所有的数据，有时还需要和其他表进行关联来获取更多信息，这时就会用到联表语句Join，它有包括左连接，右连接，内连接，全连接。对应SqlSuger的LeftJoin，RightJoin，InnerJoin，FullJoin。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});var list = Db.Queryable<School>().LeftJoin<Area>((school, area) => school.AreaCode == area.Code ).Select((school, area) => new { SchoolId = school.Id,SchoolName = school.Name,SchoolCreateTime = school.CreateTime,AreaCode = area.Code,AreaName = area.Name}).ToList();list.ForEach(m => {Console.WriteLine($"SchoolId={m.SchoolId}， SchoolName={m.SchoolName}，SchoolCreateTime={m.SchoolCreateTime}，" +$"AreaCode={m.AreaCode}，AreaName={m.AreaName}");});

上述的代码中对School和Area表进行了左连接的查询，它们共有AreaCode字段。

导航查询

导航查询和连接查询查询类似，都是对多张表进行关联，只不过它更符合面对象的思维，在一个类中存放另一个类，通过特性来配置两个类的关系，映射的字段名。

1、在School中新增一个Area类的属性

    /// <summary>/// 导航查询字段，需配置这个类的字段关联的是外部类的哪个字段/// </summary>[Navigate(NavigateType.OneToOne, nameof(AreaCode), nameof(Area.Code))]public Area AreaObject { get; set; }

2、使用Include方法进行导航查询

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取原生SQL推荐 5.1.4.63  性能OK//  Console.WriteLine(UtilMethods.GetNativeSql(sql, pars));//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 导航查询var list = Db.Queryable<School>().Includes(m => m.AreaObject).ToList();list.ForEach(m => {Console.WriteLine(m.ToString());});// 对象映射var list2 = Db.Queryable<School>().Includes(m => m.AreaObject).ToList().Adapt<List<SchoolDTO>>();list2.ForEach(m =>{Console.WriteLine(m.ToString());});// 对象映射，将不同名字的字段进行映射var list3 = Db.Queryable<School>().Includes(m => m.AreaObject).Select(m => new SchoolDTO(){SchoolName = m.Name,}, true).ToList();list3.ForEach(m => {Console.WriteLine(m.ToString());});

上述代码不仅包含导航查询，还包括对象映射的内容。

对象映射是将一个类的部分属性映射到另一个类中，如果手动操作不仅耗时，而且容易出错，这里使用的是Mapster包，在Nuget上下载后，无需任何配置就可以使用，直接调用Adapt方法即可完成映射。如果两个类的字段名不同，需要使用Select方法，给不同名字的字段进行一一匹配，并给第二个参数赋值为true，让其他字段自动填充。

下面是映射类：

    public class SchoolDTO{public int Id { get; set; }public string SchoolName { get; set; }public string Text { get; set; }public DateTime CreateTime { get; set; }/// <summary>/// 所属地区./// </summary>[SugarColumn(IsNullable = true)]public string? AreaCode { get; set; }/// <summary>/// 导航查询字段，需配置这个类的字段关联的是外部类的哪个字段/// </summary>[Navigate(NavigateType.OneToOne, nameof(AreaCode), nameof(Area.Code))]public Area AreaObject { get; set; }public override string ToString(){return $"Id={Id}，Name={Name}，Text={Text}，CreateTime={CreateTime}，AreaCode={AreaCode}，AreaObject={AreaObject?.ToString()}";}}

Json查询

Json查询原理是通过读取Json文件里的查询条件去得到不同的结果，这样就不用再去修改代码后重新编译生成程序了。

1、Json文件内容

[{"FieldName": "id","ConditionalType": "6","FieldValue": "1,2,3"},{"FieldName": "AreaCode","ConditionalType": "0","FieldValue": "110000"}
]

FieldName是查询的键名，ConditionalType是查询条件，6对应In，0对应=，FieldValue是值，翻译过来就是id是1,2,3并且AreaCode等于110000。

2、后台代码

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 读取Json，将Json转换为条件对象，再将对象放到Where方法的参数中var json = File.ReadAllText($"{Environment.CurrentDirectory}\\sqlQuery.json");var conModels = Db.Utilities.JsonToConditionalModels(json);var list = Db.Queryable<School>().Where(conModels).ToList();list.ForEach(m => {Console.WriteLine(m.ToString());});

无实体查询

无实体查询和Json查询一样都可以动态的查询数据，而不用去修改代码。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 通过字符串和匿名对象来查询SQLvar list = Db.Queryable<School>().Where("Id in(@Id) And AreaCode = @AreaCode",new {Id = new int[3] { 1, 2, 3 },AreaCode = "110000"}).ToList();list.ForEach(m => {Console.WriteLine(m);});

将上一节的Json条件拿到这里来，返回的结果是一样的。

事务

在一些情境下数据库的操作会执行多次，而这多次的操作过程中如果发生了点小意外，那么就会抛出异常，导致数据的不一致性，为了避免这种情况的发生，事务就孕育而生了。它可以让这些操作全部执行或者全部不执行，保证了数据的一致性。

在SqlSuger中有3个方法来操作事务：BeginTran开启事务，CommitTran提交事务，RollbackTran回滚事务。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});try{Db.Ado.BeginTran();Area area = new Area();area.Code = "150000";area.Name = "内蒙古自治区";Db.Insertable<Area>(area).ExecuteCommand();School model = new School(){Id = 1,AreaCode = "150000",// Name = "张三",// Text = "测试数据",};Db.Updateable<School>(model).ExecuteCommand();Db.Ado.CommitTran();}catch (Exception ex){Db.Ado.RollbackTran();throw ex;}

上述的例子中，首先添加了一个地区，然后修改School的地区代码，如果School的Name和Text为空，则会抛出异常，回滚事务，连第一步添加地区的操作也会失效，这就达到了全部不提交的效果。如果School的Name和Text不为空，则两个操作都能执行，事务便提交上去了。

事务锁

在高并发的场景下，如果对同一条数据进行修改，就有可能会出现问题，比如在抢红包时候，同时有两个用户开启它，那么红包的金额会减少两次，当剩余金额接近0的时候，同时操作就有可能出现负数的情况，这是要避免的，解决方式是给这个操作加锁，避免当A操作进来的时候加一把锁，不让B操作进来，直到A操作结束再放B操作进来。

上面描述的是悲观锁的机制，SqlSuger中使用TranLock方法加锁。

主键查询一般是行锁，如果非主键可以会变成表锁

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});try{Db.Ado.BeginTran();// 查询条件记录后锁表var model = Db.Queryable<School>().TranLock(DbLockType.Wait).Where(m => m.Id == 2).First();model.Text = "企鹅";Db.Updateable<School>(model).ExecuteCommand();Db.Ado.CommitTran();}catch (Exception ex){Db.Ado.RollbackTran();throw ex;}

AOP-面向切面编程

在之前的每个例子中都有打印SQL的委托OnLogExecuting，这个就是AOP的一个典型运用，除了打印执行的SQL还可以进行性能检测，将超过一定执行时间的C#文件的名称，代码行数，方法名都打印出来；还可以进行数据处理：在每条插入，修改，删除语句中给指定的列赋值，比如给每个创建日期，修改日期的字段赋值，这样就不用每次手动给这些字段赋值了。

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db =>{db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};db.Aop.OnLogExecuted = (sql, p) =>{// 执行时间超过1秒if (db.Ado.SqlExecutionTime.TotalSeconds > 1){//代码CS文件名var fileName = db.Ado.SqlStackTrace.FirstFileName;//代码行数var fileLine = db.Ado.SqlStackTrace.FirstLine;//方法名var FirstMethodName = db.Ado.SqlStackTrace.FirstMethodName;}};db.Aop.DataExecuting = (oldValue, entityInfo) =>{/*** 列级别事件：插入的每个列都会进事件 ***/if (entityInfo.PropertyName == "CreateTime" && entityInfo.OperationType == DataFilterType.InsertByObject){// 给每条SQL中带有CreateTime的字段赋予现在的时间entityInfo.SetValue(DateTime.Now);}};});// 插入单条数据School model = new School(){Name = "李四",Text = "测试数据",};Db.Insertable<School>(model).ExecuteCommand();

分表组件

当数据库的数量量很大的时候，查询会变得非常缓慢，因为索引的数量也是有限制的，这时候就可以进行分表操作，提高查询效率。SqlSuger内置了分表组件，只需调用SplitTables方法就可以进行CRUD操作。

1、建立实体

    [SplitTable(SplitType.Year)]//按年分表 （自带分表支持 年、季、月、周、日）[SugarTable("SplitTestTable_{year}{month}{day}")]//3个变量必须要有，这么设计为了兼容开始按年，后面改成按月、按日public class SplitTestTable{[SugarColumn(IsPrimaryKey = true)]public long Id { get; set; }public string Name { get; set; }[SugarColumn(IsNullable = true)]//设置为可空字段 (更多用法看文档 迁移)public DateTime UpdateTime { get; set; }[SplitField] //分表字段 在插入的时候会根据这个字段插入哪个表，在更新删除的时候用这个字段找出相关表public DateTime CreateTime { get; set; }}

2、执行SQL，创建数据表

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});// 初始化数据库Db.CodeFirst.SplitTables().InitTables<SplitTestTable>();    // 程序启动时加这一行,如果一张表没有会初始化一张

3、CRUD

    //创建数据库对象 (用法和EF Dappper一样通过new保证线程安全)SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig(){ConnectionString = "server=localhost;Database=mes;Uid=root;Pwd=123456",DbType = DbType.MySql,IsAutoCloseConnection = true},db => {db.Aop.OnLogExecuting = (sql, pars) =>{//获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));};});#region 插入数据//var data = new SplitTestTable()//{//    CreateTime = Convert.ToDateTime("2024-12-1"),//要配置分表字段通过分表字段建表//    Name = "Jack"//};雪花ID+表不存在会建表//Db.Insertable(data).SplitTable().ExecuteReturnSnowflakeIdList();//插入并返回雪花ID并且自动赋值ID//data = new SplitTestTable()//{//    CreateTime = Convert.ToDateTime("2023-12-1"),//要配置分表字段通过分表字段建表//    Name = "Ana"//};雪花ID+表不存在会建表//Db.Insertable(data).SplitTable().ExecuteReturnSnowflakeIdList();//插入并返回雪花ID并且自动赋值ID//data = new SplitTestTable()//{//    CreateTime = Convert.ToDateTime("2022-12-1"),//要配置分表字段通过分表字段建表//    Name = "Bob"//};雪花ID+表不存在会建表//Db.Insertable(data).SplitTable().ExecuteReturnSnowflakeIdList();//插入并返回雪花ID并且自动赋值ID　//data = new SplitTestTable()//{//    CreateTime = Convert.ToDateTime("2021-12-1"),//要配置分表字段通过分表字段建表//    Name = "Ciri"//};雪花ID+表不存在会建表//Db.Insertable(data).SplitTable().ExecuteReturnSnowflakeIdList();//插入并返回雪花ID并且自动赋值ID　#endregion// 查询数据var beginDate = Convert.ToDateTime("2021-1-1");var endDate = Convert.ToDateTime("2025-1-1");var list = Db.Queryable<SplitTestTable>().Where(it => it.Id > 0).SplitTable(beginDate, endDate).OrderBy(m => m.Id, OrderByType.Asc).ToList();// 注意：// 1、 分页有 OrderBy写 SplitTable 后面 ,uinon all后在排序// 2、 Where尽量写到 SplitTable 前面，先过滤在union all // 原理：(sql union sql2) 写SplitTable 后面生成的括号外面，写前生成的在括号里面list.ForEach(m => {Console.WriteLine(m.Id + " " + m.Name + " " + m.CreateTime);});