学习笔记19 10 月, 2026· 约 22 分钟
C# 基础
C 基础 一、索引器与相等判断 1. 索引器 Indexer 定义 索引器是一种 不带名字、使用this关键字声明、可带参数的特殊属性 ,让自定义类/结构体支持 对象[下标] 的方括号访问语法。 基础语法 底层本质 编译器自动生成一个名为 Item 的隐藏属性; obj[0] 等价调用 Item 属性。默认名可用 [I
C# 基础
一、索引器与相等判断
1. 索引器 Indexer
定义
索引器是一种不带名字、使用this关键字声明、可带参数的特殊属性,让自定义类/结构体支持 对象[下标] 的方括号访问语法。
基础语法
public string this[int index]
{
get { return _data[index]; }
set { _data[index] = value; }
}
底层本质
编译器自动生成一个名为 Item 的隐藏属性;obj[0] 等价调用 Item 属性。默认名可用 [IndexerName("XXX")] 改写,反射/序列化时看到的就是改名后的属性。
关键特性
- 索引器参数不限于int,可以使用string、元组等类型,实现字典效果
- 支持多参数,可模拟二维数组访问
- 不能声明为static,只能实例成员
- 只读索引器可用表达式体成员简写:
public string this[int i] => _data[i];(这是属性/方法的语法糖,不是 Lambda)
Unity实例
transform[0] 获取第一个子物体,Transform内部就实现了索引器。
和普通属性、方法区分
| 类型 | 调用语法 | 是否携带参数 |
|---|---|---|
| 普通属性 | obj.Name |
❌不可带参数 |
| 索引器 | obj[0] |
✅支持任意参数 |
| 普通方法 | obj.Get(0) |
✅支持任意参数 |
2. IEquatable
作用
提供高性能、类型安全的相等判断接口,用来替代 object.Equals(object obj)。
接口签名:
public interface IEquatable<T>
{
bool Equals(T other);
}
痛点:Object.Equals的缺陷
//值类型传入会装箱,产生GC开销
public virtual bool Equals(object obj);
实现收益
- 值类型:参数为T,无装箱,集合
Contains/IndexOf/Distinct性能大幅提升 - 编译期类型校验,传错类型直接编译报错
完整最佳实践
实现 IEquatable<T> 规范上必须同时重写两个方法:
override bool Equals(object obj)override int GetHashCode()
public struct Point : IEquatable<Point>
{
public int X;
public int Y;
public bool Equals(Point other)
{
return X == other.X && Y == other.Y;
}
public override bool Equals(object obj)
{
return obj is Point p && Equals(p);
}
public override int GetHashCode()
{
return HashCode.Combine(X,Y);
}
}
补充要点
IEquatable<T>.Equals()和==运算符互不绑定;想要==生效需要手动重载运算符- 引用类型class实现IEquatable无装箱收益,收益仅为类型安全
3. 补充与易错点
- 集合为什么认 IEquatable:
Dictionary/HashSet/List.Contains内部走EqualityComparer<T>.Default,它会优先调用IEquatable<T>.Equals(T),找不到才退回object.Equals。实现了接口,集合才真正走上无装箱的快路径。 - struct 的默认 Equals 很慢:
ValueType.Equals靠反射逐字段比较,是装箱 + 反射双重开销。这正是值类型实现IEquatable<T>收益最大的场景。 - 四件套必须一致:重载
==时,Equals(T)、Equals(object)、GetHashCode()、==的表达必须等价。只改其中一部分,会出现"Equals 相等但 HashSet 认为不同"的诡异行为。 - record 自动生成:C# 9 的
record/ C# 10 的record struct会自动生成Equals、GetHashCode、==、ToString,手写场景大幅减少。 - 索引器可重载:同一个类型可以写多个参数列表不同的索引器;但 Unity 的 Inspector 不显示索引器,也不能被序列化。
- 索引器不能是
static,也不能作为ref/out参数传递(属性本质上不是变量)。
二、委托、Func/Action 与事件
1. 委托、Func<>、Action<>
委托 Delegate
委托就是存放函数的容器,一种可以指向方法的数据类型。
自定义委托声明语法:delegate 返回值类型 委托名(参数列表);
Func<>
微软预定义好的泛型委托,必须带有返回值;最后一个泛型参数为返回类型。
Func<int,int,int>:两个int入参,int返回值。最多支持16个入参。
Action<>
预定义泛型委托,无返回值(void)。
三者关系
- 委托:大类,类型(盒子)
- Func/Action:系统内置现成的委托盒子
- Lambda
()=>{}:填充委托盒子的方法代码
什么时候自定义委托,什么时候用Func/Action
✅优先Func/Action:简单回调、LINQ、临时lambda ✅自定义委托:事件回调,需要强语义、提高可读性
2. 一次性事件订阅(收到消息自动取消订阅)
基础可行方案
在回调内部执行 -= 解绑,实现单次触发。
Action callback = null;
callback = () =>
{
OnMsg -= callback;
Debug.Log("一次性消息");
};
OnMsg += callback;
致命坑1:Lambda匿名委托无法解绑
//错误写法!每次 ()=>{} 创建全新委托实例,移除失败
OnMsg += ()=>{ OnMsg -= ()=>{}; };
原因:
+=和-=的委托不是同一个对象;一次性订阅必须缓存委托变量。 例外:方法组可以解绑——OnMsg += Handler; OnMsg -= Handler;指向同一个方法,能正确移除;解绑失败只发生在 lambda / 匿名方法上。
致命坑2‑Invoke快照机制
事件Invoke触发时,会生成当前委托列表的快照。回调内解绑,不会中断当前一轮已经运行的回调;解绑只会对下一次事件触发生效。
异步一次性订阅模板(Func)
Func<Task> wrapper = null;
wrapper = async () =>
{
OnAsyncEvent -= wrapper; //第一行立刻解绑,防止重入
await DoWork();
};
OnAsyncEvent += wrapper;
多线程风险
事件从子线程触发时,+=/-=存在线程竞争,可能解绑后回调仍然执行;尽量主线程调度事件。
3. 补充与易错点
- 多播委托的返回值只保留最后一个:
Func<int>用+=挂多个方法时,Invoke()返回最后一个方法的返回值,前面的返回值直接丢弃。需要收集所有返回值时,用GetInvocationList()手动遍历。 event关键字的价值:用event修饰后,外部只能+=/-=,不能=覆盖整个订阅列表、也不能从外部Invoke;写成裸委托字段则这些保护全部失效。- 委托是不可变对象:
+=实际调用Delegate.Combine生成一个新委托,-=调用Remove。所以"修改委托"其实是"换了一个对象"。 - 最大的内存泄漏来源:发布者持有订阅者引用,订阅者不取消订阅就永远无法被回收。Unity 里成对写
OnEnable订阅 /OnDisable或OnDestroy取消。 - Action 也支持 16 个参数,只是没有返回值;
Func的最后一个泛型参数固定是返回值类型。 - UnityEvent 与 C# event 不同:
UnityEvent可以在 Inspector 里拖拽绑定,且能被序列化;C#event不行。
三、类型大小、内存对齐与结构体
1. 基础类型字节占用 & 内存对齐
C#托管基础类型大小(32/64位CLR一致)
| 类型 | 字节数 |
|---|---|
| bool、byte、sbyte | 1 |
| short、ushort、char | 2 |
| int、uint、float | 4 |
| long、ulong、double | 8 |
| decimal | 16 |
引用类型变量(GameObject、class)64位程序指针占8字节,指针仅保存内存地址,不含对象本体大小。
内存对齐原理
CPU不会单字节读取内存;按块读取;变量起始地址必须是自身大小的整数倍。 编译器自动在字段之间插入Padding(空白填充字节)。
结构体对齐案例
struct S
{
byte a; //1字节
int b; //4字节
}
内存布局:0:a;1‑3:Padding;4‑7:int b →总大小:8字节,不是5字节。
结构体优化技巧
字段按从大到小顺序摆放:long→double→int→short→byte;减少Padding浪费内存。
布局控制特性
Pack = 1表示最大对齐为 1 字节,取消字段间填充;LayoutKind.Explicit必须给每个字段标[FieldOffset(n)]指定偏移,常用来做 union 式重叠布局;- 只想紧凑排列而不重叠时,用
LayoutKind.Sequential+Pack = 1更常见。
C# 结构体和 C++ 原生 dll 交互时必须保证对齐一致,否则数据错乱。
Class引用类型内存开销
托管堆上对象 = 对象头+方法表指针(64位合计16字节开销)+字段;字段同样遵守内存对齐。
2. Struct结构体包含引用类型字段
内存规则
struct本身存栈/结构体缓冲区;引用类型字段只存储8字节指针,class本体仍然存放在托管堆。
最大坑点:struct赋值是浅拷贝
struct赋值时拷贝所有字段;引用字段仅仅拷贝指针;两个结构体指向堆中同一个对象。
MyStruct a;
a.Obj = new GameObject();
MyStruct b = a;
b.Obj.name = "test"; //a.Obj.name也同步被修改!
GC回收判定
GC只关心堆对象有没有可达引用,不管引用存放位置(栈上struct字段也属于有效引用)。
所有指向堆对象的引用全部消失,堆对象才被判定为垃圾。
内存泄漏风险
static结构体缓存场景物体引用;场景销毁后结构体仍然保存引用 → 对象无法被GC回收,内存泄漏。解决:用完手动赋值 Obj=null,切断引用。
Job System红线
IJob结构体不能直接存储UnityEngine.Object引用,引擎对象非线程安全,子线程访问崩溃。
3. 补充与易错点
- struct 的"构造一定初始化"不成立:
default(T)、数组元素、字段未显式赋值时全是零值。C# 10 之前不允许自定义无参构造函数;C# 10 起允许,但仍无法阻止default产生的全零实例。 - readonly struct / in 参数:只读结构体配合
in传参可以避免大结构体的整块拷贝,是热路径上的常规优化。 - 16 字节对象头之外还有对齐:托管对象按 8 字节对齐,实际占用会向上取整,小对象(如只含一个 int 的 class)也要占 24 字节左右。
- bool 的坑:C# 的
bool是 1 字节,但 Win32 的BOOL是 4 字节;与原生代码交互时必须[MarshalAs(UnmanagedType.Bool)]或改用int。 - blittable 限制:含
string、bool、char的结构体不是 blittable,不能直接按内存块传递给原生代码,需要 Marshal 转换。 - 64 位指针恒为 8 字节:.NET 的 GC 指针压缩在 Unity 的 Mono / IL2CPP 上不启用,所以引用字段一律按 8 字节算。
- struct 默认 Equals 走反射(见本文《索引器与相等判断》),高频比较的结构体应实现
IEquatable<T>。
四、闭包与 Lambda 原理
1. 什么是闭包
Lambda / 匿名函数捕获外部函数的局部变量,匿名函数 + 被捕获的变量,整体构成闭包。
关键差异在于"被捕获的变量放在哪":
- C++ 的捕获是显式的:要么拷贝值、要么保存地址,变量本身还在原处;
- C# 的捕获是隐式的:编译器会把被捕获的变量搬家到堆上,原来栈上那份直接消失。
2. C++ Lambda
1. 捕获方式
[] 不捕获、[=] 全值捕获、[&] 全引用捕获,也可混合写 [x, &y];mutable 允许修改值捕获产生的副本。
2. 值捕获 [x]
把变量拷贝一份到 lambda 对象内部。
- lambda 对象可以存放在栈上;
- 一旦装进
std::function,整个 lambda 环境会被搬到堆上; - 多个 lambda 各自值捕获,互相独立。
3. 引用捕获 [&x]
只保存原变量的地址。
- C++ 不会自动把栈变量提升到堆;
- 如果 lambda 逃出函数(被存起来、被返回),原栈帧销毁,引用立刻变成野引用,属于未定义行为(UB)。
4. 底层形态
- lambda 本质是编译器生成的匿名类对象:捕获列表就是它的成员变量,函数体是
operator()。 std::function会把 lambda 环境放到堆,std::function析构时释放;不析构就内存泄漏。- C++ 的
T&引用只是const 指针的语法糖,没有运行时间接层,不能对引用的对象做搬迁重定向——这也是 C++ 堆不能压缩的原因之一。
3. C# 闭包:变量提升与 DisplayClass
1. 捕获的是变量,不是值
C# 没有语法层面的"值捕获 / 引用捕获",捕获的是变量本身(一块内存位置),不是捕获那一刻的值快照。
2. 变量提升:搬家,不是拷贝
核心行为是变量提升:
- ❌ 不是"把栈上的 int 拷贝一份副本放到堆";
- ✅ 是编译器重写代码,直接把被捕获的局部变量从栈搬到托管堆的隐藏闭包类里,原栈上变量彻底消失,全程只有一份内存。
这个隐藏类通常叫 DisplayClass(闭包环境类),被提升的局部变量成为它的字段。
// 源码
Action Create()
{
int num = 10;
return () => Console.WriteLine(num);
}
// 编译器改写后
private sealed class Closure
{
public int num; // 原局部变量升级为堆对象字段
public void Run() { Console.WriteLine(num); }
}
从此代码里所有 num 都访问堆上同一个字段。
3. 实例化时机
DisplayClass 在"定义 lambda 那一行"实例化,不是在 Invoke 的时候。 调用闭包只是执行方法,不会新建环境对象。
4. 委托与环境的关系
委托(Func / Action)对象的 Target 指向 DisplayClass 实例;多个委托可以指向同一个 DisplayClass。
5. 两个常见疑问
- 为什么改原变量,lambda 读到的值也跟着变? 因为"原变量"和 lambda 捕获的是堆上同一块内存,不存在栈副本,改一处全局生效。
- 函数结束、栈帧销毁,捕获的变量为什么还活着? 栈帧只清理栈内存,闭包对象在托管堆;只要还有委托持有它,GC 就不会回收,生命周期与函数栈无关。
4. 同一变量实例 vs 不同变量实例
这是 C# 闭包最容易踩错的地方,判据只有一条:看是不是同一个变量实例。
| 情况 | 结果 |
|---|---|
| 多个 lambda 捕获同一栈帧里的同一个局部变量 | 共用同一个 DisplayClass,一处修改处处可见 |
| 多个 lambda 捕获不同变量实例(不同次函数调用产生的新局部变量) | 各自独立的 DisplayClass,互不影响 |
| 捕获的是引用类型变量 | 改的是所指实例的内部数据,所有闭包都看得见 |
变量名相同 ≠ 同一个变量实例:两次调用同一个方法,形参是两份独立变量,会生成两套闭包环境。
经典坑:for 循环变量
List<Action> list = new List<Action>();
for (int i = 0; i < 3; i++)
{
list.Add(() => Console.WriteLine(i));
}
// 输出 3, 3, 3
原因:i 定义在 for 循环外部,整个循环只创建一个变量实例,被提升到堆上后所有 lambda 共享它;循环结束时 i = 3。
修复:在循环体内新建临时副本,每轮都是全新独立变量。
int temp = i;
list.Add(() => Console.WriteLine(temp));
同类坑:异步任务延迟捕获
异步任务在循环结束后才真正执行,此时循环变量已是最终值,同样输出一串相同的值。解决办法相同——使用临时副本。
5. 生命周期与回收
- 栈帧销毁不影响闭包:闭包在托管堆,由 GC 管理。
- 什么时候回收:没有任何委托再引用该
DisplayClass时,GC 自动回收。 - 闭包泄漏:事件回调、长期存活的委托会一直持有闭包对象;只要一个闭包存活,它捕获的所有对象都不会释放,即使这些变量在逻辑上已经不用了。被捕获的 GameObject 即使
Destroy(),托管侧引用仍在,资源也就回收不掉。
解决方案:事件用完手动
-=解绑委托。
6. 什么时候不会生成闭包
lambda 只访问类的成员字段、静态变量,没有捕获函数内的局部变量,就不会触发变量提升,也不会生成闭包类。
7. 闭包提升 ≠ 装箱
- 装箱:栈上的值拷贝一份,放到堆上的
object实例里,栈上那份还在。 - 闭包提升:编译器重写代码,变量一开始就在堆上的闭包类里,没有拷贝过程。
两者都会产生堆分配,但机制完全不同。
8. C++ / C# 闭包对比
| 特性 | C++ lambda | C# lambda 闭包 |
|---|---|---|
| 捕获方式 | 显式 [x] 值捕获 / [&x] 引用捕获 |
捕获变量实例,无语法选项 |
| 栈变量逃逸 | 不会自动提升到堆,容易野指针 | 自动提升到 DisplayClass 托管堆 |
| 能否移动被捕获对象 | 不能,裸指针会失效 | GC 可以移动,引用自动重定向 |
| 环境实例生成 | lambda 对象可在栈;std::function 触发堆分配 |
定义 lambda 时 new DisplayClass 堆实例 |
| 回收方式 | RAII,std::function 析构释放 |
GC,无引用后回收 |
9. 易错点汇总
- C# 中变量名相同 ≠ 同一个变量实例;两次调用同一方法,形参是两份独立变量,生成两套闭包环境。
- C++ 引用捕获不会自动上堆;C# 会自动把逃逸闭包捕获的变量提升到堆。
- GC 托管引用 ≠ C++ 引用:C# 托管引用运行时可被 GC 批量更新地址;C++ 引用底层是裸指针,无法重定向。
- 闭包没有"拆包"语法;销毁闭包对象,堆环境随之释放。
- 闭包捕获环境会持有所有提升进去的变量,即使逻辑上不用,只要闭包存活就不会释放。
A =+ 1是赋值,A += 1才是自增——运算符笔误大坑。
10. 补充与易错点
foreach与for不同:C# 5 起,foreach的迭代变量每轮都是全新变量,闭包捕获不会出现"全部读到最后一个值";for的循环变量声明在循环外,仍然共享一个实例。这是面试高频对比点。- 只访问成员字段时捕获的是
this:不生成DisplayClass,但闭包会持有this,等于延长整个对象的生命周期——比捕获局部变量更隐蔽。 - struct 的实例方法里不能捕获
this:C# 直接编译报错(CS1673),因为this在结构体方法里是值,无法提升到堆。 - 无捕获 lambda 可被缓存:C# 编译器会把不捕获任何变量的 lambda 缓存成静态实例,不会每次分配;带捕获的才必须新建
DisplayClass。 - 局部函数也走同一套机制:捕获外部变量的局部函数同样会被提升,不要以为只有 lambda 才产生闭包。
- 闭包捕获的是变量槽位,不是快照:想固定当前值,必须在捕获前复制到一个新变量。

