学习笔记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")] 改写,反射/序列化时看到的就是改名后的属性。

关键特性

  1. 索引器参数不限于int,可以使用string、元组等类型,实现字典效果
  2. 支持多参数,可模拟二维数组访问
  3. 不能声明为static,只能实例成员
  4. 只读索引器可用表达式体成员简写: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);

实现收益

  1. 值类型:参数为T,无装箱,集合 Contains/IndexOf/Distinct 性能大幅提升
  2. 编译期类型校验,传错类型直接编译报错

完整最佳实践

实现 IEquatable<T> 规范上必须同时重写两个方法:

  1. override bool Equals(object obj)
  2. 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);
    }
}

补充要点

  1. IEquatable<T>.Equals() 和 == 运算符互不绑定;想要 == 生效需要手动重载运算符
  2. 引用类型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)。

三者关系

  1. 委托:大类,类型(盒子)
  2. Func/Action:系统内置现成的委托盒子
  3. 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. 易错点汇总

  1. C# 中变量名相同 ≠ 同一个变量实例;两次调用同一方法,形参是两份独立变量,生成两套闭包环境。
  2. C++ 引用捕获不会自动上堆;C# 会自动把逃逸闭包捕获的变量提升到堆。
  3. GC 托管引用 ≠ C++ 引用:C# 托管引用运行时可被 GC 批量更新地址;C++ 引用底层是裸指针,无法重定向。
  4. 闭包没有"拆包"语法;销毁闭包对象,堆环境随之释放。
  5. 闭包捕获环境会持有所有提升进去的变量,即使逻辑上不用,只要闭包存活就不会释放。
  6. A =+ 1 是赋值,A += 1 才是自增——运算符笔误大坑。

10. 补充与易错点

  • foreach 与 for 不同:C# 5 起,foreach 的迭代变量每轮都是全新变量,闭包捕获不会出现"全部读到最后一个值";for 的循环变量声明在循环外,仍然共享一个实例。这是面试高频对比点。
  • 只访问成员字段时捕获的是 this:不生成 DisplayClass,但闭包会持有 this,等于延长整个对象的生命周期——比捕获局部变量更隐蔽。
  • struct 的实例方法里不能捕获 this:C# 直接编译报错(CS1673),因为 this 在结构体方法里是值,无法提升到堆。
  • 无捕获 lambda 可被缓存:C# 编译器会把不捕获任何变量的 lambda 缓存成静态实例,不会每次分配;带捕获的才必须新建 DisplayClass。
  • 局部函数也走同一套机制:捕获外部变量的局部函数同样会被提升,不要以为只有 lambda 才产生闭包。
  • 闭包捕获的是变量槽位,不是快照:想固定当前值,必须在捕获前复制到一个新变量。