语言特性与内存管理

// 值类型：struct / enum / 元组，存储在栈上或内联在父对象中
public struct Point
{
    public int X;
    public int Y;
}

// 引用类型：class / interface / delegate / 数组 / string，存储在托管堆上
public class Player
{
    public string Name;
    public int Level;
}

// 观察 GC 状态
GC.GetTotalMemory(false);              // 当前托管堆已用字节
GC.CollectionCount(0);                 // Gen0 回收次数
GC.CollectionCount(1);                 // Gen1 回收次数
GC.CollectionCount(2);                 // Gen2 回收次数

// 默认不要把 GC.Collect() 写进业务代码
// GC.Collect();  // 仅诊断场景使用

// IDisposable 的标准实现模式
public class ManagedConnection : IDisposable
{
    private readonly SqlConnection _conn = new("...");
    private bool _disposed;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);     // 已手动释放，跳过终结器
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
        if (disposing) _conn.Dispose();
        _disposed = true;
    }

    // 终结器：兜底，仅在忘记 Dispose 时由 GC 触发
    ~ManagedConnection() => Dispose(false);
}

// 使用：using 保证异常时也释放
using (var c = new ManagedConnection())
{
    // 业务代码
}

// 装箱：值类型 → object，产生堆分配
object boxed = 42;

// 拆箱：object → 值类型，需要类型检查
int unboxed = (int)boxed;

// 泛型集合：全程无装箱，值类型内联存储
List<int> ints = new List<int> { 1, 2, 3 };

// 老式非泛型集合：每个元素都装箱，尽量避免
// ArrayList legacy = new ArrayList { 1, 2, 3 };  // 三个装箱对象

// 约束语法
public static T Max<T>(T a, T b) where T : struct, IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

// 值类型约束让 JIT 能生成无装箱的专用代码
public static TIdentity<T>(T value) where T : struct => value;

// 用法：约束与调用端类型一致
int m = Max(3, 5);

// 位置式 record：构造函数、属性、解构、值相等全自动生成
public record Order(int Id, string Customer, decimal Total);

var order1 = new Order(1, "Alice", 99.5m);
var order2 = order1 with { Total = 120.0m };   // 非破坏性复制

Console.WriteLine(order1 == order2);            // False，Total 不同

// 模式匹配：switch 表达式 + 属性模式
static string Describe(Order o) => o switch
{
    { Total: >= 100m } => "大额订单",
    { Total: >= 50m }  => "普通订单",
    _                  => "小额订单"
};

// 类型模式
object x = "hello";
if (x is string s) { Console.WriteLine(s.Length); }

// 位置模式 + 列表模式
int[] numbers = { 1, 2, 3 };
if (numbers is [1, var second, _]) { Console.WriteLine(second); }

// 关系模式 + 逻辑模式
static string Classify(int score) => score switch
{
    < 0         => "非法",
    >= 0 and < 60 => "不及格",
    >= 60 and <= 100 => "及格",
    > 100       => "非法"
};

// 递归位置模式解构 record
if (order1 is Order(_, "Alice", var total) && total > 50)
{
    Console.WriteLine("Alice 的大额订单");
}

// Span 可以指向数组的一段，零拷贝
int[] data = { 0, 1, 2, 3, 4, 5 };
Span<int> slice = data.AsSpan(2, 3);          // 2,3,4
slice[0] = 99;                                 // 原地修改原数组

// stackalloc 在栈上分配，零 GC 分配
Span<int> buffer = stackalloc int[128];

// ref struct：只能存在于栈上，无法装箱、无法入堆
public ref struct Token
{
    public ReadOnlySpan<char> Text;
    public int Position;
}

// 传统切片：每次产生新字符串
string payload = "id:42,name:plume";
int colon = payload.IndexOf(':');
string idStr = payload.Substring(colon + 1, 2);   // 分配新串

// Span 视图：零分配切片
ReadOnlySpan<char> span = payload;
int idx = span.IndexOf(':');
ReadOnlySpan<char> idSpan = span[(idx + 1)..(idx + 3)];  // 零分配

// 解析数字也零分配
int id = int.Parse(idSpan);