语法速览：一章过完 C#

double d = 3.14;          // 小数默认是 double
    float  f = 3.14f;         // float 必须加 f
    decimal m = 19.99m;       // 钱用 decimal，必须加 m

    Console.WriteLine(0.1 + 0.2);        // 0.30000000000000004
    Console.WriteLine(0.1m + 0.2m);      // 0.3  ← decimal 精确

int[] arr = { 1, 2, 3 };              // 数组（引用类型，带边界检查）
    int[,] grid = new int[2, 3];            // 二维数组
    int[][] jag = new int[3][];              // 交错数组
    List<int> list = new();                // 泛型集合
    (int a, string b) t = (1, "x");         // 元组
    var (x, y) = t;                          // 解构

    int? maybe = null;                      // 可空值类型（Nullable<int>）
    string? s = null;                        // 可空引用类型（C# 8+，编译期警告）
    int v = maybe ?? -1;                    // ?? 提供默认值

int a;                      // 局部变量：声明后必须赋值才能用
    a = 1;
    int b = 2;
    int c = 3, d = 4;             // 可以一行声明多个
    var e = 5;                  // 推断为 int（等价于 int e = 5）
    List<int> g = new();        // 目标类型 new（右侧可省类型）

    // 常量与只读
    const double Pi = 3.14159;      // 编译期常量，必须在声明处赋值
    readonly int _id;                // 运行期只读，可在构造函数里赋值
    static readonly DateTime Start = DateTime.Now;   // 常用的"运行时静态常量"

    // 字面量小技巧
    int big = 1_000_000;          // 下划线分隔（可读性）
    int hex = 0xFF;               // 十六进制
    int bin = 0b1010;             // 二进制
    long l = 9999999999L;         // 超出 int 要加 L

string s1 = "普通\t字符串\n";          // 有转义
    string s2 = @"C:\temp\new";              // 逐字字符串：反斜杠不转义
    string s3 = $"我是 {name}，{age} 岁";      // 插值
    string s4 = $@"第 {n} 行：C:\temp";        // 插值 + 逐字
    string s5 = """ 原样 "引号" 也不怕 """;    // 原始字符串字面量（C# 11）

    char ch = 'A';                     // 单引号 = char（不是 string！）
    string one = "A";                    // 双引号 = string

// ① ?? ：左值若为 null，取右值（给默认值）
    string name = input ?? "(匿名)";

    // ② ?. ：左值若为 null，整个表达式为 null（不抛异常）
    int? len = text?.Length;              // text 是 null → len 是 null
    var city = user?.Address?.City;       // 可以链式一路判空

    // ③ ??= ：只在为 null 时赋值（惰性初始化）
    _cache ??= BuildCache();

    // ④ is ：类型判断 + 顺便取值
    if (obj is Circle c && c.R > 10) { }
    if (x is not null) { }
    if (n is > 0 and < 100) { }        // 关系模式（第 11 章）

// foreach：任何实现了 IEnumerable 的对象都能遍历
    foreach (var item in collection) { }

    // 带索引（C# 7+ 的元组解构写法）
    foreach (var (i, item) in list.Select((v, i) => (i, v))) { }

    // 自己写一个"惰性序列"：yield return
    IEnumerable<int> Fib() {
        int a = 0, b = 1;
        while (true) {
            yield return a;
            (a, b) = (b, a + b);
        }
    }

// 普通方法
    public int Add(int a, int b) { return a + b; }

    // 表达式体（一行方法）
    public int Add2(int a, int b) => a + b;

    // 默认参数（C++ 也有）
    void Log(string msg, int level = 0) { }

    // 命名实参（C# 独有，调用时可读性极强）
    Log(level: 2, msg: "hi");

    // params：可变参数（C++ 是 ... 或 initializer_list）
    int Sum(params int[] nums) => nums.Sum();
    Sum(1, 2, 3, 4);                 // 直接展开传

    // ref / out / in：见第 07 章
    void Inc(ref int x) => x++;
    bool TryGet(string k, out int v) { v = 0; return false; }
    double Dist(in BigStruct a) => 0;

    // 局部函数（方法里再定义方法）
    void Outer() {
        int Inner(int x) => x * 2;
        Console.WriteLine(Inner(3));
    }

    // 扩展方法：给"别人的类型"加方法（C++ 里做不到）
    public static class StringExt {
        public static bool IsEmail(this string s) => s.Contains('@');
    }
    // 用法："abc@x.com".IsEmail()  ← 像自带的方法一样

public class Sample : IDisposable {
        // ① 常量 / 静态字段 / 字段
        public const int Max = 100;
        private static int _counter;
        private readonly string _name;

        // ② 属性（C# 的招牌）
        public int Id { get; set; }                 // 自动属性
        public string Name => _name;                  // 只读计算属性
        public string City { get; init; } = "上海";   // init：只在创建时能赋值
        public static int Count => _counter;          // 静态属性

        // ③ 索引器：让对象支持 []
        public int this[int i] { get => i; set { } }

        // ④ 构造函数 / 静态构造函数 / 终结器
        public Sample(string name) { _name = name; _counter++; }
        static Sample() { _counter = 0; }    // 只执行一次的静态初始化
        ~Sample() { }                         // 终结器（≠ C++ 析构函数！见第 03 章）

        // ⑤ 方法 / 虚方法
        public void Run() { }
        public virtual void Step() { }

        // ⑥ 事件与委托成员
        public event Action? Changed;
        public Func<int, int>? Transform;

        // ⑦ 运算符重载 / 转换运算符
        public static Sample operator +(Sample a, Sample b) => a;
        public static implicit operator string(Sample s) => s._name;

        // ⑧ 嵌套类型
        public enum Kind { A, B }

        // ⑨ 实现接口
        public void Dispose() { }
    }

public interface IShape {                 // 接口：只声明能力
        double Area();
        string Name { get; }
    }

    public abstract class Shape : IShape {   // 抽象类：唯一基类，可给部分实现
        public abstract double Area();          // 子类必须实现
        public virtual string Name => "形状";      // 子类可选重写
    }

    public sealed class Circle : Shape {      // sealed：到此为止，不许再继承
        public double R { get; }
        public Circle(double r) => R = r;
        public override double Area() => Math.PI * R * R;
        public override string Name => "圆";
    }

    // 多态：基类引用指向派生类对象
    Shape s = new Circle(2);
    Console.WriteLine(s.Area());     // 走 Circle 的实现

    // 类型判断与转换
    if (s is Circle c) { }          // 安全：是才转
    Circle? c2 = s as Circle;           // 不是则为 null
    Circle c3 = (Circle)s;             // 强制转，失败抛异常

// 泛型类
    public class Box<T> {
        public T Value { get; set; }
    }

    // 泛型方法 + 约束
    T Max<T>(T a, T b) where T : IComparable<T>
        => a.CompareTo(b) > 0 ? a : b;

    // 常用约束：where T : struct / class / new() / Base / IFoo / notnull / unmanaged

// 自定义委托类型
    public delegate int Calculator(int a, int b);

    // 内置的（日常几乎只用这三个）
    Action<int> log = x => Console.WriteLine(x);      // 无返回值
    Func<int, int, int> add = (a, b) => a + b;      // 最后一个是返回类型
    Predicate<int> isPos = x => x > 0;              // 返回 bool

    // 多播：一个委托串多个方法（C# 独有）
    log += x => Console.WriteLine($"第二个：{x}");
    log -= log;                                       // 取消挂载

    // 事件：对外只能 += / -=
    public event EventHandler? Clicked;
    Clicked?.Invoke(this, EventArgs.Empty);

using System.Linq;

    var result = people
        .Where(p => p.Age >= 18)              // 筛选
        .OrderByDescending(p => p.Age)        // 排序
        .Select(p => p.Name)                  // 投影
        .ToList();                            // 立刻执行，得到 List

    // 聚合与判断
    int total = nums.Sum();
    double avg = nums.Average();
    bool anyBig = nums.Any(n => n > 100);
    var first = people.FirstOrDefault(p => p.Age > 60);

    // 分组
    var groups = people.GroupBy(p => p.City);

    // 查询语法（等价写法，处理 join 时更好读）
    var q = from p in people
            where p.Age > 18
            orderby p.Age descending
            select p.Name;

try {
        RiskyWork();
    }
    catch (FileNotFoundException ex) { Console.WriteLine(ex.Message); }
    catch (Exception ex) when (ex.HResult != 0) { throw; }   // when = 异常筛选
    finally { Cleanup(); }                                  // 一定执行

    // 自定义异常
    public class MyException : Exception {
        public MyException(string msg, Exception? inner = null) : base(msg, inner) { }
    }

    // 关键：重新抛出用 throw;（不要 throw ex;）
    catch (Exception ex) { Log(ex); throw; }

using var reader = new StreamReader("a.txt");   // 作用域结束自动 Dispose()
    string line = reader.ReadLine();

    using (Stream s = ..., StreamReader r = new(s)) { }   // 也能一次写多个

    lock (_gate) { }        // 自动加锁 / 解锁，相当于 C++ 的 lock_guard

    // 自己写资源类：实现 IDisposable
    public void Dispose() { /* 释放句柄、连接等 */ GC.SuppressFinalize(this); }

public async Task<string> FetchAsync(string url) {
        using var http = new HttpClient();
        string body = await http.GetStringAsync(url);   // 不阻塞线程
        return body;
    }

    // 并行等多个
    string[] all = await Task.WhenAll(urls.Select(FetchAsync));
    await Task.Delay(1000);                       // 异步延时

    // 返回值：Task（无返回）/ Task<T>（有返回）/ ValueTask<T>（高频小结果）
    // 三不要：不要 .Result / 不要 .Wait() / 不要 async void（除事件处理器）