热门项目推荐：SqlSugar - 让.NET数据操作更高效
项目地址: https://gitcode.com/DotNetNext/SqlSugar 还在为复杂的数据库操作而烦恼吗？还在为不同数据库的兼容性问题而头疼吗？SqlSugar作为一款功能强大的.NET ORM（对象关系映射）框架，将彻底改变你对数据操作的认知。本文将为你全面解析SqlSugar的核心特性、使用场景和最佳实践，让你在.NET开发中游刃有余。
什么是SqlSugar？
SqlSugar是一个开源的.NET ORM框架，由果糖大数据技术团队维护和更新。它以其开箱即用的特性、极简的API设计和全面的功能支持而闻名，支持从.NET Framework到.NET 10的所有版本。
核心优势一览表
| 特性 | 描述 | 适用场景 |
|---|---|---|
| 多数据库兼容 | 支持30+种数据库 | 跨平台、多数据库环境 |
| 高性能 | 大数据量处理优化 | 企业级应用、数据分析 |
| 低代码 | 简化开发流程 | 快速开发、原型验证 |
| 全面功能 | CRUD、事务、分表等 | 复杂业务场景 |
| SAAS支持 | 多租户架构 | 云原生应用 |
多数据库支持能力
SqlSugar的强大之处在于其广泛的数据库兼容性：
核心功能深度解析
1. 优雅的查询语法
SqlSugar提供了极其简洁的LINQ式查询语法，让复杂查询变得简单直观：
// 多表联查示例
var query = db.Queryable<Order>()
.LeftJoin<Custom>((o, cus) => o.CustomId == cus.Id)
.LeftJoin<OrderItem>((o, cus, oritem) => o.Id == oritem.OrderId)
.Where(o => o.Id == 1)
.Select((o, cus) => new ViewOrder {
Id = o.Id,
CustomName = cus.Name
})
.ToList();
生成的SQL语句清晰易懂：
SELECT
[o].[Id] AS [Id],
[cus].[Name] AS [CustomName]
FROM
[Order] o
Left JOIN [Custom] cus ON ([o].[CustomId] = [cus].[Id])
Left JOIN [OrderDetail] oritem ON ([o].[Id] = [oritem].[OrderId])
WHERE
([o].[Id] = @Id0)
2. 强大的Include查询
处理复杂对象关系时，Include功能让数据加载变得异常简单：
// 多级关联加载
var list = db.Queryable<Test>()
.Includes(x => x.Provinces, x => x.Citys, x => x.Street) // 三级关联
.Includes(x => x.ClassInfo) // 一级关联
.ToList();
// Include与Left Join结合
var complexList = db.Queryable<Student>()
.Includes(x => x.school, x => x.rooms)
.Includes(x => x.books)
.LeftJoin<Order>((x, y) => x.Id == y.sid)
.Select((x, y) => new StudentDTO {
SchoolId = x.SchoolId,
books = x.books,
school = x.school,
Name = y.Name
})
.ToList();
3. 高效的分页处理
分页查询是Web应用的常见需求，SqlSugar提供了简洁的分页API：
int pageIndex = 1;
int pageSize = 20;
int totalCount = 0;
var pageData = db.Queryable<Student>()
.Where(x => x.Status == 1)
.OrderBy(x => x.CreateTime)
.ToPageList(pageIndex, pageSize, ref totalCount);
Console.WriteLine($"总记录数: {totalCount}, 当前页: {pageIndex}");
4. 动态表达式构建
对于需要动态构建查询条件的场景，SqlSugar提供了强大的表达式构建能力：
var names = new string[] { "a", "b" };
Expressionable<Order> exp = new Expressionable<Order>();
foreach (var item in names)
{
exp.Or(it => it.Name.Contains(item));
}
var result = db.Queryable<Order>()
.Where(exp.ToExpression())
.ToList();
高级特性揭秘
多租户事务支持
在SAAS应用中，多数据库事务是常见需求：
// 创建多数据库连接
SqlSugarClient db = new SqlSugarClient(new List<ConnectionConfig>()
{
new ConnectionConfig(){ ConfigId="0", DbType=DbType.SqlServer, ConnectionString=sqlServerConn },
new ConnectionConfig(){ ConfigId="1", DbType=DbType.MySql, ConnectionString=mySqlConn }
});
var mysqlDb = db.GetConnection("1"); // MySQL数据库
var sqlServerDb = db.GetConnection("0"); // SQL Server数据库
// 跨数据库事务
db.BeginTran();
try
{
mysqlDb.Insertable(new Order() {
CreateTime = DateTime.Now,
CustomId = 1,
Name = "a",
Price = 1
}).ExecuteCommand();
sqlServerDb.Insertable(new Order() {
CreateTime = DateTime.Now,
CustomId = 2,
Name = "b",
Price = 2
}).ExecuteCommand();
db.CommitTran();
}
catch
{
db.RollbackTran();
}
单例模式与工作单元
// 全局单例配置
public static SqlSugarScope Db = new SqlSugarScope(new ConnectionConfig()
{
DbType = DbType.SqlServer,
ConnectionString = connectionString,
IsAutoCloseConnection = true
},
db => {
db.Aop.OnLogExecuting = (s, p) =>
{
Console.WriteLine(s); // 输出SQL日志
};
});
// 跨方法事务
using (var tran = Db.UseTran())
{
new UserService().CreateUser(user);
new OrderService().CreateOrder(order);
// ... 其他业务操作
tran.CommitTran();
}
自动分表功能
对于大数据量的表，SqlSugar提供了自动分表功能：
[SplitTable(SplitType.Year)] // 按年分表
[SugarTable("Order_{year}{month}{day}")]
public class Order
{
[SugarColumn(IsPrimaryKey = true)]
public long Id { get; set; }
public string Name { get; set; }
[SplitField] // 分表字段
public DateTime CreateTime { get; set; }
}
// 分表查询
var orders = db.Queryable<Order>()
.SplitTable(DateTime.Now.AddYears(-1), DateTime.Now)
.Where(x => x.Status == 1)
.ToList();
性能优化策略
批量操作支持
// 批量插入
db.Fastest<Order>().BulkCopy(orderList);
// 批量更新
db.Fastest<Order>().BulkUpdate(orderList);
// 批量合并（插入或更新）
db.Fastest<Order>().BulkMerge(orderList);
// 大数据量分页处理
List<Order> allOrders = new List<Order>();
db.Queryable<Order>()
.ForEach(it => { allOrders.Add(it); }, 2000); // 每批2000条
查询过滤器
// 全局查询过滤
db.QueryFilter.Add(new TableFilterItem<Order>(it => it.IsDeleted == false));
// 特定查询忽略过滤器
var orders = db.Queryable<Order>()
.IgnoreFilters()
.Where(x => x.CreateTime > DateTime.Now.AddDays(-7))
.ToList();
实战应用场景
场景一：电商订单系统
public class OrderService
{
public async Task<OrderResult> CreateOrder(OrderRequest request)
{
using (var tran = Db.UseTran())
{
// 1. 创建订单
var order = new Order {
OrderNo = GenerateOrderNo(),
UserId = request.UserId,
TotalAmount = request.Items.Sum(x => x.Price * x.Quantity)
};
var orderId = await Db.Insertable(order).ExecuteReturnIdentityAsync();
// 2. 创建订单项
var orderItems = request.Items.Select(x => new OrderItem {
OrderId = orderId,
ProductId = x.ProductId,
Quantity = x.Quantity,
Price = x.Price
}).ToList();
await Db.Insertable(orderItems).ExecuteCommandAsync();
// 3. 更新库存
foreach (var item in request.Items)
{
await Db.Updateable<Product>()
.SetColumns(p => p.Stock - item.Quantity)
.Where(p => p.Id == item.ProductId && p.Stock >= item.Quantity)
.ExecuteCommandAsync();
}
tran.CommitTran();
return new OrderResult { Success = true, OrderId = orderId };
}
}
}
场景二：多租户SAAS应用
public class MultiTenantService
{
public void ProcessTenantData(string tenantId)
{
// 动态切换租户数据库
var tenantDb = Db.GetConnection(tenantId);
// 租户数据隔离查询
var tenantData = tenantDb.Queryable<User>()
.Where(x => x.Status == 1)
.ToList();
// 跨租户统计（需要特殊权限）
var crossTenantStats = Db.GetConnection("admin")
.Queryable<TenantStat>()
.Where(x => x.Year == DateTime.Now.Year)
.ToList();
}
}
性能对比分析
为了更直观地展示SqlSugar的性能优势，我们来看一组对比数据：
| ORM框架 | 查询性能 | 插入性能 | 内存占用 | 学习曲线 |
|---|---|---|---|---|
| SqlSugar | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ |
| Entity Framework | ⭐⭐⭐ | ⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐ |
| Dapper | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| NHibernate | ⭐⭐ | ⭐⭐ | ⭐ | ⭐⭐ |
注：⭐越多表示越好，基于常见业务场景的相对评估
最佳实践指南
1. 连接管理策略
// 推荐使用SqlSugarScope管理连接
public static class Database
{
public static SqlSugarScope Instance { get; } = new SqlSugarScope(new ConnectionConfig
{
ConnectionString = Configuration.GetConnectionString("Default"),
DbType = DbType.SqlServer,
IsAutoCloseConnection = true
}, db => {
// 配置AOP
db.Aop.OnLogExecuting = (sql, pars) =>
{
Logger.Debug($"SQL: {sql}");
};
});
}
2. Repository模式实现
public interface IRepository<T> where T : class, new()
{
Task<T> GetByIdAsync(long id);
Task<List<T>> GetAllAsync();
Task<long> InsertAsync(T entity);
Task<bool> UpdateAsync(T entity);
Task<bool> DeleteAsync(long id);
}
public class Repository<T> : IRepository<T> where T : class, new()
{
private readonly SqlSugarScope _db;
public Repository(SqlSugarScope db)
{
_db = db;
}
public async Task<T> GetByIdAsync(long id)
{
return await _db.Queryable<T>().InSingleAsync(id);
}
public async Task<List<T>> GetAllAsync()
{
return await _db.Queryable<T>().ToListAsync();
}
public async Task<long> InsertAsync(T entity)
{
return await _db.Insertable(entity).ExecuteReturnIdentityAsync();
}
public async Task<bool> UpdateAsync(T entity)
{
return await _db.Updateable(entity).ExecuteCommandHasChangeAsync();
}
public async Task<bool> DeleteAsync(long id)
{
return await _db.Deleteable<T>().In(id).ExecuteCommandHasChangeAsync();
}
}
3. 事务处理最佳实践
public class TransactionService
{
public async Task<bool> ProcessBusiness()
{
try
{
using (var tran = Db.UseTran())
{
// 业务操作1
await ServiceA.DoSomething();
// 业务操作2
await ServiceB.DoSomethingElse();
// 业务操作3
await ServiceC.FinalOperation();
tran.CommitTran();
return true;
}
}
catch (Exception ex)
{
Logger.Error("事务处理失败", ex);
return false;
}
}
}
常见问题解决方案
Q1: 如何处理大数据量导出？
public async Task ExportBigData(string filePath)
{
using (var stream = new FileStream(filePath, FileMode.Create))
using (var writer = new StreamWriter(stream))
{
// 分批处理，避免内存溢出
int pageSize = 5000;
int pageIndex = 1;
int totalCount = 0;
do
{
var pageData = Db.Queryable<Order>()
.Where(x => x.CreateTime > DateTime.Now.AddYears(-1))
.ToPageList(pageIndex, pageSize, ref totalCount);
foreach (var order in pageData)
{
await writer.WriteLineAsync($"{order.Id},{order.OrderNo},{order.TotalAmount}");
}
pageIndex++;
} while ((pageIndex - 1) * pageSize < totalCount);
}
}
Q2: 如何优化复杂查询性能？
public List<OrderReport> GetOrderReports(DateTime startDate, DateTime endDate)
{
return Db.Queryable<Order>()
.Where(x => x.CreateTime >= startDate && x.CreateTime <= endDate)
.Select(x => new OrderReport
{
OrderId = x.Id,
OrderNo = x.OrderNo,
TotalAmount = x.TotalAmount,
// 使用SQL函数而不是内存计算
CreateDate = SqlFunc.ToDate(x.CreateTime)
})
.MergeTable() // 合并临时表
.GroupBy(x => x.CreateDate)
.Select(x => new OrderReport
{
CreateDate = x.CreateDate,
TotalOrders = SqlFunc.AggregateCount(x.OrderId),
TotalAmount = SqlFunc.AggregateSum(x.TotalAmount)
})
.ToList();
}
总结
SqlSugar作为一款功能全面、性能优异的.NET ORM框架，确实能够显著提升开发效率和应用程序性能。通过本文的详细解析，相信你已经对SqlSugar有了全面的了解：
🎯 核心优势：多数据库支持、高性能、低代码、全面功能 🚀 适用场景：企业级应用、SAAS系统、大数据处理、快速开发 💡 最佳实践：合理使用连接管理、Repository模式、事务处理
无论你是正在选择ORM框架，还是希望优化现有的数据访问层，SqlSugar都是一个值得认真考虑的优秀选择。它的简洁API设计和强大功能组合，能够让.NET开发者在数据操作方面获得前所未有的便捷和效率提升。
现在就尝试使用SqlSugar，让你的.NET数据操作变得更加高效和优雅！
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
