第一部分：C#基础入门
异步数据库操作——EF Core异步查询
实例介绍
你有没有在Web API里遇到过这样的情况？接口响应时间长，并发量一高就卡顿，甚至报503错误？排查后发现，同步EF Core操作阻塞了线程池——每个请求占用一个线程直到数据库操作完成，线程池耗尽后新请求只能排队。
而EF Core的异步操作能解决这个问题：它通过非阻塞IO释放线程处理其他请求，数据库操作完成后再回调继续执行。本节将通过Web API场景，带你掌握EF Core异步查询、增删改、批量操作的正确姿势，避免常见错误（比如死锁、线程阻塞）。
需求分析
本节需解决3类核心场景，同时规避错误写法：
1.异步查询：单条数据查询（如根据ID获取用户）、多条数据查询（如分页获取用户列表）；
2.异步增删改：新增用户、更新用户信息、删除用户；
3.异步批量操作：批量新增vb.net教程C#教程python教程SQL教程access 2010教程用户、批量更新用户状态；
4.错误写法危害：用Result/Wait导致死锁、同步操作阻塞线程、循环单条保存导致性能崩溃。
目标：让你的Web API在高并发下依然保持低延迟、高吞吐量。
代码实现
前置条件：
.NET 6+、EF Core 7+；
引用Microsoft.EntityFrameworkCore、Microsoft.EntityFrameworkCore.SqlServer；
配置SQL Server连接字符串（appsettings.json）。
准备工作：DbContext与实体定义
csharp
// 实体类：User
public class User
{
public int Id { get; set; }
public string Name { get; set; } = string.Empty;
public string Email { get; set; } = string.Empty;
public bool IsActive { get; set; } = true;
public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
}

// DbContext配置
public class AppDbContext : DbContext
{
public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

public DbSet<User> Users { get; set; } = null!; // EF Core 7+支持null!抑制警告
}

// Program.cs配置DbContext（Web API场景）
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContextPool<AppDbContext>(options => 
options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
// 注册UserService（业务逻辑层）
builder.Services.AddScoped<UserService>();

场景1：异步查询（单条/多条数据）
错误写法1：同步查询阻塞线程
csharp
// UserService错误写法：同步FirstOrDefault导致线程阻塞
public async Task<User?> GetUserByIdWrong(int id)
{
// ❌ 错误：同步方法阻塞线程，异步方法里用同步操作等于白搭
return _context.Users.FirstOrDefault(u => u.Id == id);
}

// 错误写法2：用Result导致死锁（Web API场景常见）
public User? GetUserByIdDeadlock(int id)
{
// ❌ 致命错误：在同步方法里调用异步方法的Result，导致线程死锁
return _context.Users.FirstOrDefaultAsync(u => u.Id == id).Result; 
}

问题：同步查询阻塞线程池，Result会捕获当前上下文（如ASP.NET Core的HttpContext），导致线程等待时上下文被占用，最终死锁。
正确写法：异步查询+ConfigureAwait(false)
csharp
// UserService正确写法：异步查询
public async Task<User?> GetUserByIdCorrect(int id)
{
// ✅ 用FirstOrDefaultAsync异步查询单条数据
// ConfigureAwait(false)：非UI场景不需要捕获上下文，避免死锁+提高性能
return await _context.Users.FirstOrDefaultAsync(u => u.Id == id).ConfigureAwait(false);
}

// 异步分页查询列表
public async Task<List<User>> GetUsersByPageCorrect(int pageIndex, int pageSize)
{
// ✅ 用Skip+Take实现分页，ToListAsync异步获取列表
return await _context.Users
.OrderBy(u => u.CreatedAt)
.Skip((pageIndex - 1) * pageSize)
.Take(pageSize)
.ToListAsync()
.ConfigureAwait(false);
}

场景2：异步增删改
错误写法：同步SaveChanges阻塞线程
csharp
// 错误写法：新增用户用同步SaveChanges
public async Task AddUserWrong(User user)
{
_context.Users.Add(user);
// ❌ 同步保存，阻塞线程
_context.SaveChanges();
}
正确写法：异步SaveChangesAsync
csharp
// 异步新增用户
public async Task AddUserCorrect(User user)
{
_context.Users.Add(user);
// ✅ 异步保存，返回受影响行数
return await _context.SaveChangesAsync().ConfigureAwait(false);
}

// 异步更新用户
public async Task<int> UpdateUserCorrect(User user)
{
_context.Users.Update(user); // Update是同步方法（无异步版本，因为只是修改跟踪状态）
return await _context.SaveChangesAsync().ConfigureAwait(false);
}

// 异步删除用户
public async Task<int> DeleteUserCorrect(int id)
{
var user = await _context.Users.FindAsync(id).ConfigureAwait(false);
if (user == null) return 0;

_context.Users.Remove(user);
return await _context.SaveChangesAsync().ConfigureAwait(false);
}

场景3：异步批量操作
错误写法：循环单条保存，性能崩溃
csharp
// 错误写法：批量新增用循环单条保存
public async Task BatchAddUsersWrong(List users)
{
foreach (var user in users)
{
_context.Users.Add(user);
// ❌ 每条都保存，数据库往返次数=用户数量，性能极差
await _context.SaveChangesAsync().ConfigureAwait(false);
}
}
正确写法：批量添加+单次异步保存（EF Core7+批量新增）
csharp
// 批量新增用户（EF Core7+支持AddRangeAsync）
public async Task BatchAddUsersCorrect(List users)
{
// ✅ 批量添加：AddRangeAsync（EF Core7+新增，避免循环单条Add）
await _context.Users.AddRangeAsync(users).ConfigureAwait(false);
// ✅ 单次保存，数据库往返次数=1，性能提升10倍+
return await _context.SaveChangesAsync().ConfigureAwait(false);
}

// 批量更新用户状态（EF Core5+支持ExecuteUpdateAsync）
public async Task<int> BatchUpdateUserStatusCorrect(List<int> userIds, bool isActive)
{
// ✅ 批量更新：直接生成SQL UPDATE语句，无需加载所有实体到内存
return await _context.Users
.Where(u => userIds.Contains(u.Id))
.ExecuteUpdateAsync(setters => 
setters.SetProperty(u => u.IsActive, isActive))
.ConfigureAwait(false);
}

逐行讲解
场景1：异步查询
1.FirstOrDefaultAsync：EF Core异步查询单条数据的方法，替代同步FirstOrDefault；
2.ConfigureAwait(false)：关键！在非UI场景（如Web API）中，不需要捕获当前上下文（HttpContext），避免死锁且减少上下文切换开销；
3.分页查询：Skip+Take实现分页，ToListAsync异步获取结果，避免阻塞线程。
场景2：异步增删改
1.SaveChangesAsync：异步保存所有更改，返回受影响行数，替代同步SaveChanges；
2.FindAsync：异步根据主键查询数据，比FirstOrDefaultAsync更高效（直接用主键索引）；
3.Update/Remove：无异步版本，因为只是修改DbContext的跟踪状态（内存操作），无需异步。
场景3：批量操作
1.AddRangeAsync：EF Core7+新增，批量异步添加实体，避免循环单条Add；
2.ExecuteUpdateAsync：批量更新的“核武器”——直接生成SQL UPDATE语句，无需加载实体到内存，性能比循环更新高100倍+；
3.单次SaveChangesAsync：批量操作后只调用一次保存，减少数据库往返次数（性能核心优化点）。
基础知识拓展

1. 核心概念对比

2. 关键原则
   DbContext线程安全：DbContext不能多线程共享，每个请求/任务需独立实例（Web API用AddScoped，控制台用using块）；
   避免Result/Wait：异步方法里用await，同步方法里不要调用异步EF操作；
   ConfigureAwait(false)：非UI场景（Web API、后台服务）必须加，UI场景（WPF/WinForms）不加（需要捕获UI上下文）；
   批量操作优先用EF Core原生方法：ExecuteUpdateAsync/ExecuteDeleteAsync比循环单条操作快100倍+。
3. 最佳实践
   1.Web API全异步：Controller、Service、EF操作都用异步方法（async/await）；
   2.DbContext池化：用AddDbContextPool替代AddDbContext，复用DbContext实例减少创建开销；
   3.异常处理：捕获DbUpdateException处理数据库错误（如唯一键冲突）；
   4.避免过度异步：内存操作（如实体转换）不需要异步，只在数据库IO时用异步；
   5.分页查询必加排序：Skip/Take前必须OrderBy，否则结果不稳定。
   总结
   EF Core异步操作是高并发Web API的必备技能，核心要点：
   1.用异步方法：FirstOrDefaultAsync/SaveChangesAsync/ExecuteUpdateAsync；
   2.避免阻塞：禁用Result/Wait，用await+ConfigureAwait(false)；
   3.批量操作优化：用AddRangeAsync/ExecuteUpdateAsync减少数据库往返；
   4.DbContext管理：每个请求独立实例，用池化提高性能。
   掌握这些姿势，你的Web API能轻松应对10倍以上的并发量，用户再也不会遇到“卡顿”问题！

本站原创，转载请注明出处：https://www.xin3721.com/ArticlecSharp/c49451.html