1
// 值类型包括：所有内置数值类型（int, float, double...）、
2
// bool、char、enum、struct、ref struct（Span<T>等）
3

4
// struct 的特性
5
struct Point
6
{
7
    public int X;
8
    public int Y;
9

10
    // ❌ 不能有无参构造函数（C# 9 及之前）
11
    // public Point() { X = 0; Y = 0; }  // 编译错误！
12

13
    // ✅ 可以有有参构造函数
14
    public Point(int x, int y) { X = x; Y = y; }
15

16
    // ❌ 不能有析构函数（finalizer）
17
    // ~Point() { }
18

19
    // ❌ 不能继承其他 struct 或 class（除了接口）
20
    // struct Point3D : Point { }  // 编译错误！
21

22
    // ✅ 可以实现接口（但会触发装箱，后面细讲）
23
}
24

25
// 关键：struct 的所有字段也必须是有确定大小的类型
26
// 这意味着 struct 的大小在编译期就完全确定

1
// 引用类型包括：class、interface、delegate、record、string、数组
2

3
class Player
4
{
5
    public string Name;   // Name 本身也是引用类型
6
    public int HP;        // int 是值类型，但作为 class 的字段 → 内嵌在堆上
7

8
    public Player(string name)
9
    {
10
        Name = name;
11
        HP = 100;
12
    }
13

14
    ~Player()  // Finalizer（析构函数），GC 回收前调用
15
    {
16
        // 清理非托管资源
17
    }
18
}
19

20
// 声明和初始化
21
Player p1;                // p1 是 null！（引用类型默认值是 null）
22
// p1.Name;               // ❌ NullReferenceException
23

24
Player p2 = new Player("Hero");  // new → 堆分配
25
// p2 变量本身在栈上，指向堆上的 Player 对象

1
// ✅ struct 最佳实践：小而不可变
2
struct Vector3
3
{
4
    public readonly float X, Y, Z;
5
    public Vector3(float x, float y, float z) => (X, Y, Z) = (x, y, z);
6

7
    public static Vector3 operator +(Vector3 a, Vector3 b)
8
        => new Vector3(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
9
}
10
// X, Y, Z 是 readonly → 不可变 → 不会有意外的修改传播问题
11

12
// ❌ struct 的反模式：大 struct
13
struct BadLarge
14
{
15
    public fixed byte Data[1024]; // 每次赋值都会拷贝 1KB！
16
}
17
// 微软建议 struct 大小 < 16 字节（经验值）

1
// 装箱发生的常见场景（面试重点！）
2
int value = 42;
3

4
// 场景一：赋值给 object
5
object obj = value;                          // 装箱
6

7
// 场景二：值类型调用接口方法
8
IComparable<int> comp = value;               // 装箱！
9

10
// 场景三：值类型作为泛型 object 参数
11
void Print(object o) => Console.WriteLine(o);
12
Print(value);                                // 装箱！
13

14
// 场景四：字符串拼接（+ 操作符重载接受 object）
15
string s = "value is " + value;              // 装箱！（旧版本）
16

17
// 场景五：值类型放进非泛型集合
18
ArrayList list = new ArrayList();
19
list.Add(value);                             // 装箱！
20
list.Add(value);                             // 又一次装箱！

1
// 装箱的性能代价
2
// 1. 堆分配（触发 GC）
3
// 2. 拷贝开销
4
// 3. 拆箱时的类型检查
5

6
// ✅ 避免装箱的手段
7
// 手段一：用泛型代替 object
8
List<int> list = new List<int>();  // 不用 ArrayList
9
list.Add(42);                       // 零装箱
10

11
// 手段二：用泛型约束 + 接口
12
interface IResettable { void Reset(); }
13
struct Data : IResettable
14
{
15
    public int Value;
16
    public void Reset() => Value = 0;
17
}
18

19
void Process<T>(T item) where T : IResettable
20
{
21
    item.Reset();  // 不装箱！泛型约束下的接口调用是零开销
22
}
23

24
// 手段三：重载代替 object 参数
25
void Print(int x) => Console.WriteLine(x);     // 不装箱
26
void Print(string s) => Console.WriteLine(s);  // 本来就不装箱

1
// C++ 里你可以 int* p = &arr[3]; *p = 10;
2
// C# 的安全等价物是 ref
3

4
int[] array = { 1, 2, 3, 4, 5 };
5

6
// ref 局部变量：给数组元素起一个引用别名（不是拷贝！）
7
ref int element = ref array[2];
8
element = 42;
9
Console.WriteLine(array[2]);  // 42 —— 直接修改了数组元素
10

11
// ref 返回值：让方法返回一个"指向内部数据的引用"
12
ref int Find(int[] arr, int target)
13
{
14
    for (int i = 0; i < arr.Length; i++)
15
        if (arr[i] == target)
16
            return ref arr[i];
17
    throw new InvalidOperationException("not found");
18
}
19

20
ref int found = ref Find(array, 3);
21
found = 100;  // 直接修改了数组里的元素

1
// 实战：用 ref 返回在 struct 数组里原地修改大 struct
2
struct Transform
3
{
4
    public float PosX, PosY, PosZ;
5
    public float RotX, RotY, RotZ, RotW;
6
    // 这么大的 struct（28 字节），拷贝代价不小
7
}
8

9
class TransformManager
10
{
11
    private Transform[] _transforms = new Transform[1000];
12

13
    // ❌ 不好：返回副本，修改无效
14
    public Transform GetTransform_copy(int i) => _transforms[i];
15

16
    // ✅ 好：返回 ref，零拷贝原地修改
17
    public ref Transform GetTransform(int i) => ref _transforms[i];
18
}
19

20
// 使用
21
manager.GetTransform(5).PosX = 10.0f;  // 直接写入了数组里的 struct
22
// 对比 C++: transforms[5].posX = 10.0f;  —— 完全一样的体验！

1
// 三个修饰符，都是传引用，但语义不同
2

3
// ref：双向，调用前必须初始化
4
void Multiply(ref int x, int factor) { x *= factor; }
5
int a = 5;
6
Multiply(ref a, 3);  // a = 15
7

8
// out：单向（输出），方法必须赋值，调用前不需要初始化
9
bool TryParse(string s, out int result)
10
{
11
    // result 在方法内必须赋值
12
    result = 0;
13
    return int.TryParse(s, out result);
14
}
15
TryParse("123", out int b);  // b = 123
16

17
// in：单向（只读），传引用但禁止修改，避免大 struct 拷贝
18
void PrintVector(in Vector3 v)
19
{
20
    Console.WriteLine($"{v.X}, {v.Y}, {v.Z}");
21
    // v.X = 10;  // ❌ 编译错误！in 参数是只读的
22
}
23
Vector3 v = new Vector3(1, 2, 3);
24
PrintVector(v);    // 传引用，不拷贝 12 字节
25
PrintVector(in v); // 显式 in（可选）

1
// Span<T> 是什么？一个"栈上的安全指针+长度"对
2
// 它可以指向：数组、栈上内存(stackalloc)、非托管内存、字符串
3

4
// Span<T> 的内存布局（和 C++ 的 std::span 类似）：
5
// struct Span<T> {
6
//     internal readonly ref T _reference;  // 指向数据的引用
7
//     internal readonly int _length;       // 长度
8
// }
9
// 一共就 2 个指针大小（在 64 位上是 16 字节）
10

11
// 基本用法：零分配的切片
12
int[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
13
Span<int> span = data;                // 指向整个数组
14
Span<int> slice = span.Slice(2, 5);   // 指向索引 2~6，零分配零拷贝！
15

16
slice[0] = 42;
17
Console.WriteLine(data[2]);           // 42 —— 通过 span 修改了原数组

1
// Span<T> 是一个 ref struct —— 只能在栈上存在
2
// 这个限制保证了它永远不会逃逸到堆上，不会被 GC 追踪
3

4
// ❌ Span<T> 不能做的事：
5
Span<int> span = stackalloc int[100];
6
// object o = span;             // ❌ 不能装箱
7
// List<Span<int>> list = ...;  // ❌ 不能做泛型参数
8
// Span<int>[] arr = ...;       // ❌ 不能是数组元素
9
// async Task M() { Span<int> s; } // ❌ 不能出现在 async 方法中
10

11
// 原因：Span<T> 内部持有的是 managed pointer（ref），
12
// 而堆上的对象会被 GC 移动，ref 指向的内存可能失效。
13
// 所以把它锁死在栈上，栈上的东西不会被 GC 移动。
14

15
// 如果需要把 Span 存到堆上 → 用 Memory<T>
16
Memory<int> mem = data.AsMemory();
17
// Memory<T> 不是 ref struct，可以放进 List、class 字段、async 方法

1
// stackalloc：在栈上分配数组
2
Span<int> buffer = stackalloc int[128];  // 栈上 512 字节，不涉及 GC
3
for (int i = 0; i < buffer.Length; i++)
4
    buffer[i] = i * i;
5

6
// 对比 C++: int buffer[128]; —— 一样的栈分配
7

8
// ReadOnlySpan<T>：只读版本
9
void Process(ReadOnlySpan<int> data)
10
{
11
    // 只读访问，不能修改
12
    for (int i = 0; i < data.Length; i++)
13
        Console.WriteLine(data[i]);
14
}
15

16
int[] arr = { 1, 2, 3 };
17
List<int> list = new List<int> { 4, 5, 6 };
18
Process(arr);                             // ✅ 数组
19
Process(list.ToArray());                  // ❌ ToArray 额外分配
20
Process(CollectionsMarshal.AsSpan(list)); // ✅ 直接获取 List 内部 span，零分配

1
// 值类型默认不能为 null，但你有时候需要"没有值"这个状态
2
int? maybe = null;           // 等价于 Nullable<int>
3
if (maybe.HasValue)
4
    Console.WriteLine(maybe.Value);
5

6
// Nullable<T> 本身也是一个 struct：
7
// struct Nullable<T> where T : struct {
8
//     bool hasValue;
9
//     T value;
10
// }
11

12
// 语法糖
13
int? a = 5;
14
int b = a ?? 0;       // null 合并：a 有值取 a，否则取 0
15
int c = a ?? default; // 等价于 a ?? 0
16

17
// C# 8.0 起：可空引用类型（Nullable Reference Types）
18
// 这是编译期检查，不是新的运行时类型
19
#nullable enable
20
string? maybeNull = null;    // 可以赋 null
21
string mustNotBeNull = "hi";  // 警告：不要赋 null
22

23
void Process(string? s)
24
{
25
    // Console.WriteLine(s.Length);  // ⚠️ 警告：可能为 null
26
    if (s != null)
27
        Console.WriteLine(s.Length); // ✅ 安全
28

29
    // 或用 null 宽容操作符（告诉编译器"我知道不是 null"）
30
    Console.WriteLine(s!.Length);
31
}

1
// ====== 同一语义在不同语言中的写法 ======
2

3
// 值语义对象
4
// C++:    Vec3 v(1, 2, 3);
5
// C#:     Vector3 v = new Vector3(1, 2, 3);  // ← new 不代表堆分配！
6

7
// 引用语义对象
8
// C++:    Player* p = new Player("hero");
9
// C#:     Player p = new Player("hero");      // ← class 自动是引用
10

11
// 只读引用传参
12
// C++:    void f(const Vec3& v);
13
// C#:     void f(in Vector3 v);
14

15
// 返回值避免拷贝
16
// C++:    Vec3& get(int i) { return data[i]; }
17
// C#:     ref Vector3 get(int i) => ref data[i];
18

19
// 指向数组的视图
20
// C++:    std::span<int> s(arr, 5);
21
// C#:     Span<int> s = arr.AsSpan(2, 5);
22

23
// 可空语义
24
// C++:    std::optional<int> x;
25
// C#:     int? x = null;

1
struct Counter { public int Value; }
2

3
class Program
4
{
5
    static void Main()
6
    {
7
        var list = new List<Counter> { new Counter { Value = 0 } };
8

9
        // Counter c = list[0];   // 拷贝！
10
        // c.Value = 10;           // 修改的是副本，不是 list 里的！
11

12
        // ❌ 直观但错误的写法
13
        list[0].Value = 10;  // CS1612: 不能修改 list[0] 的成员
14
                             // 因为 list[0] 返回的是临时副本！
15
    }
16
}
17
// ✅ 正确：通过 ref 或者替换整个元素
18
// list[0] = new Counter { Value = 10 };

1
// ECS（Entity-Component-System）是 C# 结构体最重要的游戏应用
2
// Component 全部用 struct，密集存储在线性数组中，缓存友好
3

4
struct Position : IComponent { public float X, Y, Z; }
5
struct Velocity : IComponent { public float VX, VY, VZ; }
6
struct Health : IComponent { public int Current, Max; }
7

8
class ComponentStore<T> where T : struct, IComponent
9
{
10
    private T[] _data = new T[1024];  // 连续内存，和 C++ vector<T> 一样
11
    private int _count = 0;
12

13
    // 添加组件（值拷贝）
14
    public void Add(T component) => _data[_count++] = component;
15

16
    // 通过 ref 访问，零拷贝
17
    public ref T Get(int index) => ref _data[index];
18
}
19

20
// 使用：所有 Position 在内存中紧密排列 → 缓存命中率极高
21
var positions = new ComponentStore<Position>();
22
positions.Add(new Position { X = 0, Y = 0, Z = 0 });
23
ref var pos = ref positions.Get(0);
24
pos.X += 1.0f;  // 直接修改了数组里的 struct

1
// C# 中的数学库（包括 Unity 的 Vector3、Matrix4x4）全部用 struct
2
// 理由：① 频繁创建临时值，栈分配无 GC 压力
3
//       ② 值语义符合数学直觉
4

5
// 每帧大量调用的代码：
6
void Update()
7
{
8
    Vector3 gravity = new Vector3(0, -9.81f, 0);
9
    Vector3 velocity = new Vector3(1, 0, 0);
10
    Vector3 position = new Vector3(100, 50, 0);
11

12
    // 这一行创建了很多临时 Vector3，但全在栈上，零 GC
13
    position = position + velocity * Time.deltaTime
14
               + 0.5f * gravity * Time.deltaTime * Time.deltaTime;
15

16
    // 如果 Vector3 是 class，这一行就是多次堆分配 → GC 卡顿
17
}

1
// 网络消息缓冲区：在栈上解析包头，零分配
2
ReadOnlySpan<byte> buffer = stackalloc byte[1500]; // MTU 大小
3

4
// 假设收到数据填充了 buffer
5
void ParsePacket(ReadOnlySpan<byte> buffer)
6
{
7
    // 解析包头（切片，零拷贝）
8
    var headerSpan = buffer.Slice(0, 4);          // 4 字节头
9
    var bodySpan = buffer.Slice(4);               // 剩余是包体
10

11
    // 把 span 转为结构体（用 MemoryMarshal，零拷贝）
12
    ref var header = ref MemoryMarshal.AsRef<PacketHeader>(headerSpan);
13

14
    int messageId = header.MessageId;
15
    int bodyLength = header.Length;
16

17
    // 处理包体（继续切片，全程零分配）
18
    var payload = bodySpan.Slice(0, bodyLength);
19
    ProcessPayload(payload);
20
}
21

22
[StructLayout(LayoutKind.Sequential, Pack = 1)]
23
struct PacketHeader
24
{
25
    public short MessageId;
26
    public short Length;
27
}