baozaotumao
522 lines
12 KiB
Markdown
522 lines
12 KiB
Markdown
# C# / .NET Code Review Guide
|
||
|
||
> C# / .NET 8 代码审查指南，覆盖 C# 12 新特性、异步编程、EF Core 性能、ASP.NET Core 最佳实践、依赖注入、LINQ 等核心主题。
|
||
|
||
## 目录
|
||
|
||
- [C# 12 新特性](#c-12-新特性)
|
||
- [异步编程](#异步编程)
|
||
- [EF Core 性能](#ef-core-性能)
|
||
- [ASP.NET Core 最佳实践](#aspnet-core-最佳实践)
|
||
- [依赖注入](#依赖注入)
|
||
- [LINQ 最佳实践](#linq-最佳实践)
|
||
- [Review Checklist](#review-checklist)
|
||
|
||
---
|
||
|
||
## C# 12 新特性
|
||
|
||
### Primary Constructors（非 record 类型）
|
||
|
||
```csharp
|
||
// ❌ 样板代码过多的传统构造函数
|
||
public class ProductService
|
||
{
|
||
private readonly ProductDbContext _db;
|
||
private readonly ILogger<ProductService> _logger;
|
||
|
||
public ProductService(ProductDbContext db, ILogger<ProductService> logger)
|
||
{
|
||
_db = db;
|
||
_logger = logger;
|
||
}
|
||
}
|
||
|
||
// ✅ Primary Constructor——简洁的依赖注入
|
||
public class ProductService(ProductDbContext db, ILogger<ProductService> logger)
|
||
{
|
||
public async Task<Product?> GetAsync(int id)
|
||
=> await db.Products.FindAsync(id);
|
||
}
|
||
|
||
// ⚠️ 注意：primary constructor 参数不是属性，不能被重新赋值
|
||
// ⚠️ 如果需要长期存储，显式声明字段
|
||
public class OrderService(OrderDbContext db)
|
||
{
|
||
private readonly OrderDbContext _db = db; // 显式捕获
|
||
}
|
||
```
|
||
|
||
### Collection Expressions
|
||
|
||
```csharp
|
||
// ❌ 传统集合初始化
|
||
int[] nums = new int[] { 1, 2, 3 };
|
||
List<string> names = new List<string> { "alice", "bob" };
|
||
|
||
// ✅ 集合表达式
|
||
int[] nums = [1, 2, 3];
|
||
List<string> names = ["alice", "bob"];
|
||
Span<char> span = ['a', 'b'];
|
||
|
||
// ✅ 展开运算符
|
||
int[] merged = [..nums, 4, 5];
|
||
```
|
||
|
||
### Default Lambda Parameters
|
||
|
||
```csharp
|
||
// ❌ 重载 lambda
|
||
var add = (int a, int b) => a + b;
|
||
var addDefault = (int a) => a + 1;
|
||
|
||
// ✅ 默认参数
|
||
var add = (int a, int b = 1) => a + b;
|
||
```
|
||
|
||
---
|
||
|
||
## 异步编程
|
||
|
||
### Task.Wait() / .Result / async void 是严重反模式
|
||
|
||
```csharp
|
||
// ❌ Task.Wait() —— 死锁风险（同步阻塞异步操作）
|
||
public ActionResult<Data> Get(int id)
|
||
{
|
||
var data = _service.GetDataAsync(id).Result; // 死锁！
|
||
return Ok(data);
|
||
}
|
||
|
||
// ❌ async void —— 异常无法捕获，会崩溃进程
|
||
public async void HandleEvent()
|
||
{
|
||
await _service.ProcessAsync(); // 异常直接崩溃
|
||
}
|
||
|
||
// ✅ async Task —— 全链路异步
|
||
public async Task<ActionResult<Data>> Get(int id)
|
||
{
|
||
var data = await _service.GetDataAsync(id);
|
||
return Ok(data);
|
||
}
|
||
```
|
||
|
||
### ConfigureAwait(false) 用于库代码
|
||
|
||
```csharp
|
||
// ❌ 库代码不必要地捕获 SynchronizationContext
|
||
public class LibraryService
|
||
{
|
||
public async Task<string> GetDataAsync()
|
||
{
|
||
var response = await _httpClient.GetAsync("/api/data");
|
||
return await response.Content.ReadAsStringAsync();
|
||
}
|
||
}
|
||
|
||
// ✅ 库代码使用 ConfigureAwait(false) 避免死锁
|
||
public class LibraryService
|
||
{
|
||
public async Task<string> GetDataAsync()
|
||
{
|
||
var response = await _httpClient.GetAsync("/api/data").ConfigureAwait(false);
|
||
return await response.Content.ReadAsStringAsync().ConfigureAwait(false);
|
||
}
|
||
}
|
||
```
|
||
|
||
### CancellationToken 传播
|
||
|
||
```csharp
|
||
// ❌ 丢弃 CancellationToken
|
||
public async Task<List<User>> SearchAsync(string query)
|
||
{
|
||
return await _db.Users.Where(u => u.Name.Contains(query)).ToListAsync();
|
||
}
|
||
|
||
// ✅ 全链路传递 CancellationToken
|
||
public async Task<List<User>> SearchAsync(string query, CancellationToken ct = default)
|
||
{
|
||
return await _db.Users
|
||
.Where(u => u.Name.Contains(query))
|
||
.ToListAsync(ct);
|
||
}
|
||
```
|
||
|
||
### Async Disposal
|
||
|
||
```csharp
|
||
// ❌ 同步 dispose 异步资源
|
||
public class DataClient : IDisposable
|
||
{
|
||
public void Dispose()
|
||
{
|
||
_httpClient.Dispose(); // 可能丢弃正在进行的请求
|
||
}
|
||
}
|
||
|
||
// ✅ IAsyncDisposable
|
||
public class DataClient : IAsyncDisposable
|
||
{
|
||
public async ValueTask DisposeAsync()
|
||
{
|
||
await _stream.DisposeAsync();
|
||
}
|
||
}
|
||
|
||
// ✅ 调用方使用 await using
|
||
await using var client = new DataClient();
|
||
```
|
||
|
||
---
|
||
|
||
## EF Core 性能
|
||
|
||
### N+1 查询问题
|
||
|
||
```csharp
|
||
// ❌ 经典 N+1——每个 Blog 触发一次查询获取 Posts
|
||
foreach (var blog in await context.Blogs.ToListAsync())
|
||
{
|
||
foreach (var post in blog.Posts) // 每次循环都查询数据库！
|
||
{
|
||
Console.WriteLine(post.Title);
|
||
}
|
||
}
|
||
|
||
// ✅ Eager Loading + 投影
|
||
await foreach (var blog in context.Blogs
|
||
.Select(b => new { b.Url, b.Posts })
|
||
.AsAsyncEnumerable())
|
||
{
|
||
foreach (var post in blog.Posts)
|
||
Console.WriteLine(post.Title);
|
||
}
|
||
```
|
||
|
||
### 过度获取（不投影）
|
||
|
||
```csharp
|
||
// ❌ 加载所有列——只需要 Url 时加载了全部字段
|
||
var urls = await context.Blogs.ToListAsync();
|
||
|
||
// ✅ 只投影需要的字段
|
||
var urls = await context.Blogs
|
||
.Select(b => b.Url)
|
||
.ToListAsync();
|
||
```
|
||
|
||
### 缺少分页
|
||
|
||
```csharp
|
||
// ❌ 无界结果集
|
||
var posts = await context.Posts
|
||
.Where(p => p.Title.StartsWith("A"))
|
||
.ToListAsync(); // 可能有百万条记录！
|
||
|
||
// ✅ 限制结果数量
|
||
var posts = await context.Posts
|
||
.Where(p => p.Title.StartsWith("A"))
|
||
.OrderBy(p => p.Id)
|
||
.Skip((page - 1) * pageSize)
|
||
.Take(pageSize)
|
||
.ToListAsync();
|
||
```
|
||
|
||
### Cartesian Explosion（JOIN 笛卡尔爆炸）
|
||
|
||
```csharp
|
||
// ❌ 多个 Include 创建大量重复数据
|
||
var blogs = await context.Blogs
|
||
.Include(b => b.Posts)
|
||
.Include(b => b.Tags)
|
||
.ToListAsync(); // 每行重复 Blog 数据
|
||
|
||
// ✅ 使用 AsSplitQuery 拆分查询
|
||
var blogs = await context.Blogs
|
||
.Include(b => b.Posts)
|
||
.Include(b => b.Tags)
|
||
.AsSplitQuery()
|
||
.ToListAsync();
|
||
```
|
||
|
||
### 只读场景缺少 AsNoTracking
|
||
|
||
```csharp
|
||
// ❌ 默认跟踪——只读查询也付出跟踪开销
|
||
var products = await context.Products.ToListAsync();
|
||
|
||
// ✅ AsNoTracking——跳过变更跟踪，更快且更省内存
|
||
var products = await context.Products
|
||
.AsNoTracking()
|
||
.ToListAsync();
|
||
```
|
||
|
||
### 列上函数阻止索引使用
|
||
|
||
```csharp
|
||
// ✅ 可以使用索引——sargable
|
||
var posts1 = await context.Posts
|
||
.Where(p => p.Title.StartsWith("A"))
|
||
.ToListAsync();
|
||
|
||
// ❌ 无法使用索引——全表扫描
|
||
var posts2 = await context.Posts
|
||
.Where(p => p.Title.EndsWith("A"))
|
||
.ToListAsync();
|
||
|
||
// ❌ 列上套函数——全表扫描
|
||
var posts3 = await context.Posts
|
||
.Where(p => p.Title.ToLower() == "foo")
|
||
.ToListAsync();
|
||
```
|
||
|
||
### 同步 vs 异步数据库访问
|
||
|
||
```csharp
|
||
// ❌ 同步数据库调用——阻塞线程
|
||
var products = context.Products.ToList();
|
||
context.SaveChanges();
|
||
|
||
// ✅ 异步数据库调用
|
||
var products = await context.Products.ToListAsync();
|
||
await context.SaveChangesAsync();
|
||
```
|
||
|
||
---
|
||
|
||
## ASP.NET Core 最佳实践
|
||
|
||
### HttpClient 误用
|
||
|
||
```csharp
|
||
// ❌ 每次请求创建新的 HttpClient——socket 耗尽
|
||
using var client = new HttpClient();
|
||
var response = await client.GetAsync("https://api.example.com/data");
|
||
|
||
// ✅ IHttpClientFactory 注入
|
||
public class MyService
|
||
{
|
||
private readonly HttpClient _client;
|
||
public MyService(HttpClient client) => _client = client; // 从工厂注入
|
||
}
|
||
```
|
||
|
||
### HttpContext 在后台线程中使用
|
||
|
||
```csharp
|
||
// ❌ 在后台任务中捕获 scoped 服务——请求结束后已释放
|
||
_ = Task.Run(async () =>
|
||
{
|
||
await context.SaveChangesAsync(); // ObjectDisposedException!
|
||
});
|
||
|
||
// ✅ 创建新的 scope
|
||
_ = Task.Run(async () =>
|
||
{
|
||
await using var scope = serviceScopeFactory.CreateAsyncScope();
|
||
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
|
||
await db.SaveChangesAsync();
|
||
});
|
||
```
|
||
|
||
### Request.Form 同步访问
|
||
|
||
```csharp
|
||
// ❌ 同步读取 Form——sync over async
|
||
var form = HttpContext.Request.Form;
|
||
|
||
// ✅ 异步读取
|
||
var form = await HttpContext.Request.ReadFormAsync();
|
||
```
|
||
|
||
### 异常用于控制流
|
||
|
||
```csharp
|
||
// ❌ 用异常判断是否存在——异常开销大，比直接检查慢得多
|
||
try
|
||
{
|
||
var user = await _db.Users.FirstAsync(u => u.Id == id);
|
||
}
|
||
catch (InvalidOperationException)
|
||
{
|
||
return NotFound();
|
||
}
|
||
|
||
// ✅ 使用检查而非异常
|
||
var user = await _db.Users.FirstOrDefaultAsync(u => u.Id == id);
|
||
if (user is null) return NotFound();
|
||
```
|
||
|
||
### 响应头在 Body 之后设置
|
||
|
||
```csharp
|
||
// ❌ body 已发送后再设置 header——抛异常
|
||
await next(context);
|
||
context.Response.Headers["X-Custom"] = "value"; // 可能抛异常！
|
||
|
||
// ✅ 使用 OnStarting 回调
|
||
context.Response.OnStarting(() =>
|
||
{
|
||
context.Response.Headers["X-Custom"] = "value";
|
||
return Task.CompletedTask;
|
||
});
|
||
await next(context);
|
||
```
|
||
|
||
---
|
||
|
||
## 依赖注入
|
||
|
||
### Scoped 服务注入 Singleton
|
||
|
||
```csharp
|
||
// ❌ Scoped 服务注入 Singleton——生命周期不匹配
|
||
services.AddSingleton<BackgroundWorker>();
|
||
services.AddScoped<IUserRepository, UserRepository>();
|
||
|
||
// BackgroundWorker 是 Singleton，UserRepository 是 Scoped
|
||
// → UserRepository 在多个请求间共享或已释放
|
||
|
||
// ✅ 在 Singleton 中通过 IServiceProvider 创建 scope
|
||
public class BackgroundWorker : BackgroundService
|
||
{
|
||
private readonly IServiceScopeFactory _scopeFactory;
|
||
|
||
public BackgroundWorker(IServiceScopeFactory scopeFactory)
|
||
=> _scopeFactory = scopeFactory;
|
||
|
||
protected override async Task ExecuteAsync(CancellationToken ct)
|
||
{
|
||
await using var scope = _scopeFactory.CreateAsyncScope();
|
||
var repo = scope.ServiceProvider.GetRequiredService<IUserRepository>();
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## LINQ 最佳实践
|
||
|
||
### ToList 之后再 LINQ
|
||
|
||
```csharp
|
||
// ❌ 先 ToList 再过滤——全表加载到内存
|
||
var results = context.Posts
|
||
.Where(p => p.Title.StartsWith("A"))
|
||
.ToList()
|
||
.Where(p => SomeClientFilter(p)); // 客户端过滤，已加载全部行
|
||
|
||
// ✅ 尽可能让数据库执行过滤
|
||
var results = await context.Posts
|
||
.Where(p => p.Title.StartsWith("A") && SomeDbFilter(p))
|
||
.AsAsyncEnumerable()
|
||
.Where(p => SomeClientFilter(p)) // 只过滤数据库返回的行
|
||
.ToListAsync();
|
||
```
|
||
|
||
### Count() vs Any()
|
||
|
||
```csharp
|
||
// ❌ Count() 执行完整查询
|
||
if (context.Users.Count() > 0) { /* ... */ }
|
||
|
||
// ✅ Any() 更高效——遇到第一条记录就返回
|
||
if (await context.Users.AnyAsync()) { /* ... */ }
|
||
```
|
||
|
||
### 多次枚举 IEnumerable
|
||
|
||
```csharp
|
||
// ❌ IEnumerable 被枚举两次
|
||
public void Process(IEnumerable<int> numbers)
|
||
{
|
||
if (numbers.Any()) // 第一次枚举
|
||
{
|
||
foreach (var n in numbers) // 第二次枚举（可能是重新查询）
|
||
{
|
||
Console.WriteLine(n);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ✅ 如果需要多次使用，先物化
|
||
public void Process(IEnumerable<int> numbers)
|
||
{
|
||
var list = numbers.ToList(); // 只枚举一次
|
||
if (list.Any())
|
||
{
|
||
foreach (var n in list)
|
||
{
|
||
Console.WriteLine(n);
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### Select 中的副作用
|
||
|
||
```csharp
|
||
// ❌ Select 中执行副作用——不可预测的执行时机
|
||
var results = users.Select(u =>
|
||
{
|
||
_logger.LogInformation($"Processing {u.Name}"); // 副作用！
|
||
return u.Email;
|
||
}).ToList();
|
||
|
||
// ✅ 副作用放在 foreach 中
|
||
foreach (var user in users)
|
||
{
|
||
_logger.LogInformation("Processing {Name}", user.Name);
|
||
}
|
||
var results = users.Select(u => u.Email).ToList();
|
||
```
|
||
|
||
---
|
||
|
||
## Review Checklist
|
||
|
||
### C# 12 新特性
|
||
|
||
- [ ] Primary constructor 参数不被重新赋值
|
||
- [ ] 集合表达式语法一致（不混用新旧风格）
|
||
|
||
### 异步编程
|
||
|
||
- [ ] 无 `Task.Wait()`、`.Result`、`async void`
|
||
- [ ] 库代码使用 `ConfigureAwait(false)`
|
||
- [ ] `CancellationToken` 全链路传递
|
||
- [ ] 异步资源使用 `IAsyncDisposable` / `await using`
|
||
- [ ] 不混用同步和异步数据访问
|
||
|
||
### EF Core
|
||
|
||
- [ ] 无 N+1 查询（导航属性在循环中访问）
|
||
- [ ] 投影 `Select()` 避免过度获取
|
||
- [ ] 分页：`ToListAsync()` 前有 `Take()`/`Skip()`
|
||
- [ ] 多个 `Include()` 使用 `AsSplitQuery()`
|
||
- [ ] 只读查询使用 `AsNoTracking()`
|
||
- [ ] 列上无函数调用阻止索引使用
|
||
- [ ] 数据库调用全部异步
|
||
|
||
### ASP.NET Core
|
||
|
||
- [ ] HttpClient 通过 `IHttpClientFactory` 获取
|
||
- [ ] 后台任务中不直接使用 scoped 服务
|
||
- [ ] 使用 `ReadFormAsync` 代替 `Request.Form`
|
||
- [ ] 异常不用于控制流
|
||
- [ ] 响应头通过 `OnStarting` 设置
|
||
|
||
### 依赖注入
|
||
|
||
- [ ] Scoped 服务不注入 Singleton
|
||
- [ ] 后台任务创建新 scope
|
||
|
||
### LINQ
|
||
|
||
- [ ] 无不必要的 `ToList()` 后再 LINQ
|
||
- [ ] `Any()` 代替 `Count() > 0`
|
||
- [ ] IEnumerable 不被多次枚举（或先物化）
|
||
- [ ] Select 中无副作用
|