09.2 阶段 1:C# 语言核心
所属:全栈开发面试题库 / 学习路径 / 09 C# 与 .NET 全栈
本页目录
一、阶段定位
阶段 0 只解决"能在本机编译运行",本阶段开始真正接触 C# 的语言模型。重点不是语法清单,而是 C# 与 Java、PHP、Python 在数据表示上的三处硬差异:
- 值类型与引用类型是两条语义线:
int、struct赋值复制整个值,class、数组赋值只复制引用,同一块数据被两个变量指向。这决定了"改了 A 会不会影响 B"。 - 可空是双层概念:
int?(Nullable<int>)是值类型的可空,string?是引用类型的可空注解——后者只是编译器分析提示,运行时并不真的阻止 null。 - LINQ 是惰性的:
Where、Select不立即执行,每次枚举才重新跑一遍;把它当立即执行写,就会出现"查了两次库""副作用执行两次"。
本阶段与前后阶段的衔接:往下接 阶段 2 类型系统进阶与现代特性,那时讨论的是 record、模式匹配、async/await、Span<T>,前提是你已经能分清值与引用、会写委托与事件。往上承接阶段 0 的工程骨架,本阶段要在这个工程里写类库与命令行工具。跳过值/引用语义直接进现代特性,后面遇到"两个订单对象互相污染""集合里装箱导致 GC 压力"时会无从下手。
原有卡点的可判断现象依据:
- 值类型与引用类型赋值混淆:判断标准是——把一个对象传给方法后在方法里改了字段,调用方看到的也变了,你却以为应该是副本。能复述"class 传的是引用,struct 传的是值"才算过关。
- 可空引用类型告警被整体关掉:判断标准是——在 csproj 里加
<Nullable>disable</Nullable>或全程#nullable disable,却不理解警告在说什么。合格做法是逐条看警告并修代码。 - 委托与事件说不清:判断标准是——被问到"
public event EventHandler E与public EventHandler E的区别"时答不出外部只能+=不能=。 - 把 LINQ 当立即执行:判断标准是——对同一个
IEnumerable枚举两次,发现里面的Console.WriteLine或数据库查询执行了两遍,却没意识到是延迟执行。
二、阶段目标与投入
学完本页,应当能用可观察的行为证明以下六条能力:
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能解释并演示值类型与引用类型赋值的差异 | 写一个 struct 与一个 class,各传一次,对比"修改是否影响调用方" |
能正确处理可空类型,区分 int? 与 string? 的运行时差异 |
对 int? 用 HasValue,对 string? 理解警告来源 |
能定义泛型方法与 where 约束,说明为什么用泛型 |
写一个泛型 Max<T> 并对比非泛型版本的装箱开销 |
| 能写委托、事件订阅,并在调用方正确退订 | 事件触发时订阅者收到通知;退订后不再收到 |
| 能用 LINQ 查询集合,并说清每次枚举发生了什么 | 对带副作用的枚举两次,能解释结果为何是两份 |
能对非托管资源实现 IDisposable 并在调用方释放 |
文件/连接在 using 块结束时被释放 |
建议学时:
- 全职(每天有效学习 4–6 小时):2 周,约 60–70 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周,约 70 小时。
学时分配建议:值/引用类型与内存 20%、面向对象与接口 20%、可空与泛型 15%、委托与事件 10%、集合与 LINQ 20%、异常与 IDisposable 15%。值/引用语义与 LINQ 是面试与线上问题的重灾区,时间要给够。
三、先修自检
进入本阶段前逐条自检;任何一条做不到,先回到对应页面补齐。
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| dotnet CLI 可用 | dotnet new console、dotnet run 能正常运行 |
09.1 阶段 0 |
| 解决方案结构 | 有 src/ 与 tests/ 的目录概念 |
09.1 阶段 0 |
| 变量与函数 | 知道变量、函数参数、返回值是什么 | 09.1 阶段 0 |
| Git 提交 | 能把练习代码提交到仓库 | 09.1 阶段 0 |
经验判断:写过 Java 的人容易把 string 当可变类型拼接,也容易把 C# 的 struct 当 Java 没有的概念忽略掉;写过 JS 的人容易把"引用类型赋值复制引用"与"深拷贝"混淆。这两类偏差都要在练习里主动纠正。
四、知识地图
"掌握程度"分三档:了解、会用、能讲清原理。
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 值与引用类型 | 栈与堆、赋值/传参语义、== 比较的是什么 |
能讲清原理 | 04.6 CSharp 与 .NET |
| 面向对象 | 类、接口、抽象类、继承多态、virtual/override |
会用 | 04.6 CSharp 与 .NET |
| 装箱与可空 | 装箱堆分配、Nullable<T>、可空引用类型与 ! |
能讲清原理 | 04.6 CSharp 与 .NET |
| 泛型与约束 | 泛型类/方法、where T : ... 约束组合 |
会用 | 04.6 CSharp 与 .NET |
| 委托与事件 | delegate、event、订阅/退订、内存泄漏 |
能讲清原理 | 04.6 CSharp 与 .NET |
| 集合与 LINQ | List<T>/Dictionary、Where/Select、延迟执行 |
能讲清原理 | 04.6 CSharp 与 .NET |
| 字符串与异常 | string 不可变、StringBuilder、异常层级、try/catch/finally、IDisposable |
会用 | 04.6 CSharp 与 .NET |
进度管理建议:把这张表复制到笔记里,每学完一个模块把"掌握程度"往下调一档;三档都到位再进 阶段 2。《知识点全清单》是更细的全量清单。
五、分模块精讲
5.1 值类型与引用类型:栈与堆的语义线
为什么需要它:这是 C# 最核心的分野。没搞清这一点,后面"两个对象互相污染""集合里频繁装箱"全部无法解释。
核心机制:
- 值类型:
int、double、bool、struct、enum。变量本身持有数据,赋值、传参、返回都复制整个值。 - 引用类型:
class、数组、string、delegate。变量持有的是"数据在堆上的地址",赋值、传参只复制地址,多个变量指向同一块堆对象。 ==对值类型比较内容;对引用类型默认比较"是否同一对象"(除非重载了Equals)。string虽然是引用类型,但行为上像不可变的值:任何"修改"都产生新字符串,所以它是安全的。- 方法传参默认是"按值传递"——对引用类型来说,复制的是引用本身,而不是对象;
ref/out才能让方法替换调用方的变量本身。
最小可运行示例:
// struct 是值类型:赋值复制整个值
struct Point { public int X; }
// class 是引用类型:赋值复制引用
class RefPoint { public int X; }
Point s = new Point { X = 1 };
Point s2 = s; // s2 是 s 的完整副本
s2.X = 99;
Console.WriteLine(s.X); // 1:s 不受影响
RefPoint r = new RefPoint { X = 1 };
RefPoint r2 = r; // r2 与 r 指向同一个对象
r2.X = 99;
Console.WriteLine(r.X); // 99:改 r2 等于改 r
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 方法里改了字段,调用方却看不到(struct) | struct 传参复制了一份 | 把类型改为 class,或用 ref 传参 |
== 两个内容相同的对象判等失败 |
引用类型默认比较地址 | 重写 Equals/GetHashCode,或用 record |
| 大 struct 做参数导致性能下降 | 每次传参复制整个结构体 | 控制 struct 大小(建议不超过 16 字节),或用 class |
面试考法:高频题是"值类型和引用类型的区别""struct 和 class 怎么选"。要答出:赋值复制内容 vs 复制引用;小而频繁的值用 struct(如 DateTime、Guid),有身份、有可变状态、较大的用 class。追问常落到"string 为什么是引用类型却表现得像值"。
5.2 面向对象:类、接口、继承与多态
为什么需要它:C# 的依赖注入、策略模式、测试 Mock 全部建立在接口抽象之上。不会写接口就无法在后续阶段做可测试的设计。
核心机制:
class默认继承自object;单继承,接口多实现。interface只定义契约,不写实现;abstract class可带部分实现。virtual允许派生类用override重写;sealed禁止再被继承。- 多态:基类引用指向派生类实例,调用时按实际类型分派。
- 构造函数链:派生类构造默认先调基类无参构造,有参时用
: base(args)指定。
最小可运行示例:
// 定义一个接口契约
interface INotifier { void Send(string message); }
class EmailNotifier : INotifier
{
public void Send(string message) => Console.WriteLine($"邮件: {message}");
}
class SmsNotifier : INotifier
{
public void Send(string message) => Console.WriteLine($"短信: {message}");
}
// 依赖接口而不是具体实现:便于替换与测试
class OrderService
{
private readonly INotifier _notifier;
public OrderService(INotifier notifier) => _notifier = notifier;
public void Place() => _notifier.Send("订单已创建");
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 派生类构造报"基类无无参构造" | 基类只定义了有参构造 | 派生类构造用 : base(args) 显式调用 |
| 重写方法没生效 | 基类方法没标 virtual,或派生类用了 new 而非 override |
基类加 virtual,派生类用 override |
| 接口膨胀,实现类被迫实现用不到的方法 | 违反接口隔离 | 拆小接口,用显式实现隔离 |
面试考法:常见问法是"接口和抽象类怎么选""为什么要依赖接口而不是具体类"。要答出:接口定义能力契约、支持多实现,抽象类为共享实现提供模板;依赖接口是为了可替换、可 Mock、可测试。
5.3 装箱、拆箱与可空类型
为什么需要它:这是 C# 性能与"null 引用异常"的双重源头。不理解 int? 与 string? 的区别,后面写 Dictionary<string, int> 时频繁装箱,或在上线后踩 NullReferenceException。
核心机制:
- 装箱:值类型(如
int)转成object或接口类型时,会在堆上分配一个包装对象,把值拷进去。拆箱是逆过程,要显式转换。 Nullable<T>:值类型的可空,int?是Nullable<int>的语法糖,内部有bool HasValue与T Value;没装箱,开销小。- 可空引用类型:从 C# 8 起,
string?是编译器分析注解,告诉编译器"这个引用可能是 null"。运行时它和普通string完全一样,不会阻止你给它赋 null。 !(null 宽容运算符):告诉编译器"这里我保证不是 null",绕过告警——但运行时如果真的是 null 照样抛NullReferenceException。?.(空条件运算符):name?.Length在 name 为 null 时返回 null 而不抛异常。
最小可运行示例:
// 装箱:int 转 object 会在堆上分配
int number = 42;
object boxed = number; // 装箱:堆上多一个对象
int unboxed = (int)boxed; // 拆箱
// Nullable<T>:值类型可空,没有装箱
int? maybe = null;
Console.WriteLine(maybe.HasValue); // False
Console.WriteLine(maybe ?? -1); // -1:空合并运算符
// 可空引用类型:编译期告警,运行时无差别
string? name = GetName(); // 编译器提示可能为 null
int len = name!.Length; // ! 告诉编译器"我保证非 null",但真为 null 照样抛异常
int? safeLen = name?.Length; // 安全写法:name 为 null 时 safeLen 为 null
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 高频装箱导致 GC 压力大 | 用 ArrayList 或 object 集合装值类型 |
改用泛型集合 List<int> |
Nullable<T>.Value 抛 InvalidOperationException |
对 HasValue == false 的实例取 .Value |
先判 HasValue 或用 ?? |
把 string? 当运行时强制非空 |
以为 string? 会阻止 null |
理解它只是编译期注解,运行时仍要判空 |
滥用 ! 消除告警 |
用 ! 压警告但运行时真为 null |
用 ?. 与 ?? 做防御式判空 |
面试考法:高频题是"装箱是什么、代价在哪""int? 和 string? 有什么区别"。要答出:装箱是值类型转 object 的堆分配,频繁发生会产生 GC 压力;int? 是 Nullable<int> 带 HasValue,string? 只是编译期注解不改变运行时行为。追问常落到"! 运算符到底有没有用"。
5.4 泛型与约束
为什么需要它:泛型是 C# 避免装箱、保证类型安全的核心机制。不理解 where 约束,写不出通用的数据结构,也看不懂 EF Core、ASP.NET Core 的泛型 API。
核心机制:
- 泛型让一份代码适用于多种类型,且编译期就确定类型,比
object方案免去装箱与强制转换。 where T : struct限定值类型;where T : class限定引用类型;where T : new()限定有无参构造;where T : IFoo限定实现某接口。- 约束可以组合:
where T : class, new()。 - 泛型在运行时按具体类型共享实现(引用类型共享一份代码,值类型各一份)。
最小可运行示例:
// 泛型方法:在编译期确定 T,无装箱
T Max<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) >= 0 ? a : b;
Console.WriteLine(Max(3, 5)); // 5
Console.WriteLine(Max("cat", "dog")); // dog
// 泛型类:带约束组合
class Repository<T> where T : class, new()
{
public T CreateNew() => new T();
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
泛型方法里想调用 T 的方法却编译失败 |
没有加接口约束 | 加 where T : ISomeInterface |
new T() 编译报错 |
没加 new() 约束 |
加 where T : new() |
用 object 做参数的集合,频繁装箱 |
泛型写得不对或退化成 object | 改用 List<T> |
面试考法:常见问法是"泛型相比非泛型集合的好处""where 约束有哪些"。要答出:类型安全(编译期检查)、避免装箱、代码复用;约束用于在泛型代码里安全地调用 T 的能力。
5.5 委托与事件
为什么需要它:委托与事件是 C# 实现回调、发布订阅、事件处理的基础。不理解"事件是委托的封装",后面看不懂 SignalR、UI 绑定、IHostedService 的回调模型。
核心机制:
- 委托:一种类型安全的方法引用,
delegate void Notify(string msg)定义一个能装"参数 string、无返回"方法的类型。 - 事件:基于委托的发布订阅封装。
public event EventHandler E让外部只能+=/-=,不能直接=或调用——保护了内部委托链。 - 事件触发时,订阅者按订阅顺序执行;某个订阅者抛异常会中断后续订阅者(除非手动处理)。
- 退订:订阅了事件却不退订,发布者与订阅者之间形成引用,导致订阅者无法被 GC 回收——这是经典内存泄漏。
最小可运行示例:
// 定义事件参数与事件发布者
class OrderEventArgs : EventArgs { public string OrderId { get; init; } = ""; }
class OrderService
{
// event 封装了委托:外部只能 += / -=,不能 = 或调用
public event EventHandler<OrderEventArgs>? Created;
public void Create(string id)
{
Console.WriteLine($"订单 {id} 已创建");
// 触发事件:先判空,避免无订阅者时空引用
Created?.Invoke(this, new OrderEventArgs { OrderId = id });
}
}
// 订阅与退订
var svc = new OrderService();
svc.Created += OnCreated; // 订阅
svc.Create("A001");
svc.Created -= OnCreated; // 退订:避免订阅者被长期持有
svc.Create("A002"); // 这次不触发
static void OnCreated(object? sender, OrderEventArgs e)
=> Console.WriteLine($"收到通知: {e.OrderId}");
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 订阅者对象无法被 GC 回收 | 订阅了事件却没退订,发布者持有订阅者引用 | 用完 -= 退订,或用弱事件模式 |
外部能 = 覆盖事件订阅 |
用了 public EventHandler E 而非 public event |
改成 public event EventHandler E |
| 无订阅者时触发事件抛 NullReferenceException | Created(this, ...) 在无订阅时委托为 null |
用 Created?.Invoke(...) |
面试考法:高频题是"委托和事件的区别""事件为什么要退订"。要答出:委托是方法引用类型,事件是对委托的封装(外部只能订阅/退订);不退订会让发布者持有订阅者引用,阻止其被 GC 回收,造成内存泄漏。
5.6 常用集合与 LINQ 基础
为什么需要它:集合与 LINQ 是日常代码用得最多的部分。不理解 LINQ 的延迟执行,就会反复踩"查了两次""副作用跑两遍"。
核心机制:
List<T>:动态数组,按索引访问 O(1),末尾追加均摊 O(1),中间插入 O(n)。Dictionary<TKey,TValue>:哈希表,查找/增删平均 O(1);键不可变(用作键后不要改其GetHashCode)。HashSet<T>:哈希集合,去重、判存在 O(1)。- LINQ 延迟执行:
Where、Select、OrderBy只是"描述查询",不立即执行;只有foreach、ToList、Count等枚举时才真正跑一遍。 - 立即执行算子:
ToList、ToArray、Count、First、ToArray会立刻枚举并固化结果。
最小可运行示例:
var numbers = new List<int> { 1, 2, 3, 4, 5 };
// 延迟执行:这里还没真正过滤
IEnumerable<int> query = numbers.Where(n =>
{
Console.WriteLine($"过滤 {n}");
return n % 2 == 0;
});
// 第一次枚举:才真正执行过滤
Console.WriteLine("--- 第一次枚举 ---");
Console.WriteLine(query.Count()); // 打印 5 次"过滤 n",结果 2
// 第二次枚举:又从头跑一遍
Console.WriteLine("--- 第二次枚举 ---");
Console.WriteLine(query.Count()); // 又打印 5 次"过滤 n"
// 用 ToList 固化结果,避免重复执行
List<int> cached = query.ToList();
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 同一个查询执行了两遍 | LINQ 延迟执行,每次枚举都重跑 | 立即 ToList() 固化 |
| 修改了源集合后,后续枚举结果变了 | 延迟执行,枚举时读的是当前源 | 固化结果,或确认业务上是否要实时读 |
Dictionary 键被修改后查不到 |
键对象的 GetHashCode 变了 |
键用不可变类型(如 string),或改完后重建字典 |
First() 在空集合上抛异常 |
无元素 | 用 FirstOrDefault() |
面试考法:高频题是"LINQ 是立即执行还是延迟执行""IEnumerable 与 IQueryable 的区别"。要答出:标准查询算子是延迟执行,只有枚举才跑;IEnumerable 是内存枚举,IQueryable 带表达式树可被翻译成 SQL(这一点阶段 2 展开)。追问常到"多次枚举为什么危险"。
5.7 字符串、异常层级与 IDisposable
为什么需要它:字符串拼接、异常处理、资源释放是三个"看着简单、实际全是坑"的日常。string 不可变、异常该 catch 什么、IDisposable 何时调,都必须讲清。
核心机制:
string不可变:任何"修改"(Replace、Substring、+)都产生新字符串,循环拼接会产生大量中间对象。- 高频拼接用
StringBuilder,预分配容量减少扩容。 - 异常层级:
Exception是基类,派生如ArgumentException、InvalidOperationException、IOException;catch应捕获具体类型,不要catch (Exception)兜一切。 finally无论是否异常都会执行;using是try/finally的语法糖,在退出时自动调Dispose()。IDisposable:持有非托管资源(文件句柄、网络连接)的类型应实现它,调用方用using确保释放。
最小可运行示例:
// 高频拼接用 StringBuilder,不要用 +=
var sb = new StringBuilder();
sb.AppendLine("订单明细");
for (int i = 0; i < 100; i++) sb.AppendLine($"行 {i}");
string report = sb.ToString();
// 用 using 确保资源释放,等价于 try/finally
try
{
using var reader = new StreamReader("data.txt");
string content = reader.ReadToEnd();
Console.WriteLine(content.Length);
} // reader.Dispose() 在这里自动调用
catch (IOException ex)
{
// 捕获具体异常类型,带上上下文
Console.WriteLine($"读取失败: {ex.Message}");
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
循环里 str += part 后内存暴涨 |
每次拼接产生新字符串 | 用 StringBuilder |
catch (Exception ex) 吞掉了所有错误 |
捕获过宽,掩盖 bug | 只捕获能处理的具体异常 |
| 文件句柄/连接没释放 | 没写 using |
用 using var 包裹资源对象 |
Dispose 后继续用对象 |
释放后再访问 | 释放后丢弃引用,不要复用 |
面试考法:常见问法是"string 为什么不可变""using 和 try/finally 的关系""什么时候该实现 IDisposable"。要答出:不可变让字符串安全共享、可做字典键;using 是 try/finally 的语法糖;持有非托管资源时实现 IDisposable。
六、分层练习
三档练习逐档升级,上一档没做完不要跳。
6.1 复现型(照着做,目标是跑通 + 能解释)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 值/引用语义实验 | 写一个 struct 和一个 class,各赋值一次对比 | 能说出 struct 副本不受影响、class 互相影响 | 1 小时 |
| 装箱实验 | 把 int 装进 ArrayList 与 List<int> 对比 |
能说清前者有装箱、后者没有 | 1 小时 |
| 可空类型处理 | 对 int? 与 string? 分别判空 |
HasValue、?.、?? 都用对 |
1 小时 |
| 事件订阅与退订 | 写一个发布者,订阅后触发,再退订 | 退订后事件不再通知订阅者 | 1.5 小时 |
| LINQ 延迟执行实验 | 写一个带 Console.WriteLine 的 Where,枚举两次 |
能解释为什么过滤打印了两遍 | 1 小时 |
6.2 改造型(给出现成代码,改出正确行为)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 消除装箱 | 把 ArrayList 装值类型改成 List<int> |
无装箱,代码编译通过 | 1 小时 |
| 修一个"改了不生效"的方法 | 给定 struct 参数方法,改 class 或用 ref |
调用方能看到修改 | 1.5 小时 |
| 把字符串拼接改成 StringBuilder | 给定循环 +=,改为预分配的 StringBuilder |
拼接结果一致,中间对象减少 | 1 小时 |
| 修复事件内存泄漏 | 给定订阅不退订的代码,加退订 | 订阅者可被回收 | 1.5 小时 |
| 收窄异常捕获 | 给定 catch (Exception),改为具体异常 |
只捕获能处理的类型 | 1 小时 |
6.3 设计型(自己定方案,目标是能交付、能讲清取舍)
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| CSV 数据统计命令行工具 | 读取 CSV,按字段聚合,支持错误输入 | 非法输入被捕获并给出明确提示;资源用 using |
6 小时 |
| 待办事项列表 | 增删改查,数据用集合管理,事件通知变更 | 操作通过事件通知;集合选择有理由 | 5 小时 |
| 类型安全的缓存结构 | 用泛型 + 约束写一个简单缓存 | 编译期类型安全;能讲清 where 约束 | 4 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| 修改 struct 字段后调用方看不到 | struct 传参复制了一份 | 确认类型是 struct 还是 class | 改 class 或用 ref 传参 |
| 两个内容相同对象判等为 false | 引用类型默认比地址 | 看是否重写了 Equals |
重写 Equals/GetHashCode 或用 record |
| 高频装箱导致 GC 压力大 | 用了 ArrayList/object 集合 |
检查集合类型 | 改用 List<T> |
对 Nullable<T>.Value 抛 InvalidOperationException |
对 HasValue 为 false 的实例取 Value | 先判 HasValue | 用 ?? 或判空 |
| 事件订阅者无法回收 | 订阅了事件没退订 | 检查是否有 -= |
用完退订 |
| LINQ 副作用执行了两次 | 延迟执行,枚举两遍 | 看是否枚举两次 | 立即 ToList() 固化 |
| 循环字符串拼接内存暴涨 | += 产生中间字符串 |
看循环内拼接 | 用 StringBuilder |
| 资源没释放 | 没写 using |
检查资源对象 | 用 using var 包裹 |
八、出口条件
全部勾选后再进入 阶段 2 类型系统进阶与现代特性。
- [ ] 能画出 struct 与 class 赋值后"谁复制了谁",并解释
==比较的是什么 - [ ] 能说清装箱发生在什么场景,并用泛型集合避免它
- [ ] 能区分
int?与string?的运行时差异,正确使用?.、??、! - [ ] 能写泛型方法与
where约束,说明为什么用泛型 - [ ] 能写委托与事件,说明外部为什么不能
=覆盖、为什么要退订 - [ ] 能解释 LINQ 延迟执行,遇到"执行两次"能一次定位
- [ ] 能对资源实现
IDisposable并用using释放 - [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径
自测题(先自己想,再看要点):
int与自定义 struct 赋值,和 class 赋值,行为有什么不同?- 要点:struct/int 复制整个值;class 复制引用,多变量指向同一对象。
int?与string?在运行时有区别吗?- 要点:有。
int?是Nullable<int>带 HasValue;string?只是编译期注解,运行时与普通 string 一样,不阻止 null。
- 要点:有。
- 为什么
public event EventHandler E比public EventHandler E安全?- 要点:event 封装了委托链,外部只能
+=/-=,不能=覆盖别人的订阅、也不能外部触发。
- 要点:event 封装了委托链,外部只能
- 为什么订阅了事件不退订会内存泄漏?
- 要点:发布者持有委托,委托持有订阅者方法,使订阅者无法被 GC 回收。
- LINQ 的
Where在什么时候真正执行?- 要点:枚举时(foreach、ToList、Count 等)才执行;多次枚举会重跑。
- 为什么
string拼接在循环里要用StringBuilder?- 要点:string 不可变,每次
+都产生新字符串,循环里产生大量中间对象;StringBuilder 可变缓冲。
- 要点:string 不可变,每次
using var reader = ...在什么时候调用Dispose()?- 要点:离开所在代码块(方法/作用域)时自动调用,等价于 try/finally。