C# 高级篇#

本篇覆盖集合、泛型、委托事件、多线程、反射特性和高级排序，学完能写出专业级 C# 程序。

一、集合#

1. List（动态数组）#

List 就是一个会自动变长的数组，最常用的集合。

声明与常用方法：

1
List<int> list = new List<int>();
2
list.Add(1);                    // 添加单个元素
3
list.AddRange(new[] { 2, 3 });  // 添加多个元素
4
list.Remove(2);                 // 删除元素 2
5
list.RemoveAt(0);               // 删除索引 0 处的元素
6
bool has = list.Contains(3);    // 是否包含 3 → True
7
int idx = list.IndexOf(3);      // 查索引，找不到返回 -1
8
list.Sort();                    // 排序
9
list.Clear();                   // 清空
10
// 此时 list.Count → 0

Count vs Capacity：

1
List<int> list = new List<int>();
2
for (int i = 0; i < 5; i++) list.Add(i);
3
Console.WriteLine(list.Count);      // 5（实际元素数）
4
Console.WriteLine(list.Capacity);   // 8（底层分配的容量，会按倍数扩张）

坑：遍历时删除元素会跳过（因为删除后后面元素前移，索引却继续 +1）：

1
List<int> nums = new List<int> { 1, 2, 2, 3, 4 };
2
// 错误写法：会漏删
3
foreach (var n in nums) { /* 不能在 foreach 里改集合，会抛异常 */ }
4

5
// 正确写法 1：倒序遍历
6
for (int i = nums.Count - 1; i >= 0; i--)
7
{
8
    if (nums[i] == 2) nums.RemoveAt(i);
9
}
10
// 正确写法 2：用 RemoveAll
11
nums.RemoveAll(n => n == 2);

2. Dictionary<TKey, TValue>（字典）#

通过 key 快速查 value，查找速度接近 O(1)。

1
Dictionary<string, int> dict = new Dictionary<string, int>();
2
dict["apple"] = 5;                  // 索引赋值（key 不存在会新增）
3
dict.Add("banana", 3);              // Add 方法
4

5
// 访问
6
int a = dict["apple"];              // → 5（key 不存在会抛 KeyNotFoundException）
7
bool ok = dict.TryGetValue("pear", out int v);  // ok → False，v → 0
8

9
// 常用方法
10
bool has = dict.ContainsKey("apple");   // → True
11
dict.Remove("banana");                  // 删除
12
Console.WriteLine(dict.Count);          // → 1
13

14
// 遍历
15
foreach (KeyValuePair<string, int> kvp in dict)
16
{
17
    Console.WriteLine($"{kvp.Key} = {kvp.Value}");   // apple = 5
18
}

坑： Add 重复 key 会抛异常，但索引赋值 dict["key"] = v 不会（会覆盖）。

1
dict.Add("apple", 10);    // 若 apple 已存在 → ArgumentException
2
dict["apple"] = 10;       // 安全，覆盖原值

3. Queue（队列，先进先出 FIFO）#

像排队买饭，先来的先服务。

1
Queue<string> queue = new Queue<string>();
2
queue.Enqueue("A");       // 入队
3
queue.Enqueue("B");
4
Console.WriteLine(queue.Peek());   // 查看队首 → A（不移除）
5
string first = queue.Dequeue();    // 出队 → A
6
Console.WriteLine(queue.Count);    // → 1

4. Stack（栈，后进先出 LIFO）#

像叠盘子，最后放的最先拿。

1
Stack<int> stack = new Stack<int>();
2
stack.Push(1);             // 入栈
3
stack.Push(2);
4
Console.WriteLine(stack.Peek());   // 查看栈顶 → 2
5
int top = stack.Pop();     // 出栈 → 2
6
Console.WriteLine(stack.Count);    // → 1

5. HashSet（集合，无重复）#

自动去重，可以做集合运算。

1
HashSet<int> setA = new HashSet<int> { 1, 2, 3, 4 };
2
HashSet<int> setB = new HashSet<int> { 3, 4, 5, 6 };
3

4
setA.Add(1);          // 已存在，不会重复添加，Count 不变
5
bool has = setA.Contains(2);   // → True
6

7
// 集合运算（会修改 setA 本身）
8
// setA.UnionWith(setB);       // 并集：{1,2,3,4,5,6}
9
// setA.IntersectWith(setB);   // 交集：{3,4}
10
// setA.ExceptWith(setB);      // 差集：{1,2}

6. 集合对比表#

集合	特点	主要用途	访问复杂度
List	有序、可重复、可变长	通用动态数组	索引 O(1)，查找 O(n)
Dictionary<K,V>	key-value、key 唯一	快速查找	O(1)
Queue	FIFO	任务排队、BFS	入出 O(1)
Stack	LIFO	撤销、DFS、表达式求值	入出 O(1)
HashSet	无重复、无序	去重、集合运算	O(1)

二、泛型#

1. 为什么用泛型#

类型安全：编译期就能发现类型错误
避免装箱拆箱：值类型存到 ArrayList 要装箱，存到 List<int> 不用
代码复用：一份代码适用多种类型

2. 泛型类#

1
class MyList<T>
2
{
3
    public T[] items = new T[10];
4
    public int Count { get; private set; }
5

6
    public void Add(T item)
7
    {
8
        items[Count++] = item;
9
    }
10

11
    public T Get(int index) => items[index];
12
}
13

14
// 使用
15
MyList<int> list = new MyList<int>();
16
list.Add(10);
17
Console.WriteLine(list.Get(0));   // → 10

3. 泛型方法#

1
T GetFirst<T>(T[] arr)
2
{
3
    if (arr == null || arr.Length == 0) return default(T);
4
    return arr[0];
5
}
6

7
int n = GetFirst<int>(new[] { 5, 6, 7 });   // → 5
8
string s = GetFirst(new[] { "hi", "yo" });   // 类型推断 → hi

4. 泛型约束（where）#

约束告诉编译器 T 必须满足什么条件。

1
// 引用类型
2
class A<T> where T : class { }
3

4
// 值类型
5
class B<T> where T : struct { }
6

7
// 有无参公共构造
8
class C<T> where T : new()
9
{
10
    public T Create() => new T();
11
}
12

13
// 实现某接口
14
class D<T> where T : IComparable<T>
15
{
16
    public T Max(T a, T b) => a.CompareTo(b) >= 0 ? a : b;
17
}
18

19
// 继承自某类
20
class E<T> where T : Animal { }
21

22
// 多约束（同时满足）
23
class F<T> where T : class, IComparable<T>, new() { }

5. 常见泛型集合#

List<T>、Dictionary<TKey, TValue>、Queue<T>、Stack<T>、HashSet<T>（前面已介绍）。

6. 坑#

泛型类型参数不能直接实例化，除非加了 new() 约束：

1
class Wrong<T>
2
{
3
    // public T item = new T();   // 编译错误！T 不一定是可实例化的
4
}
5

6
class Right<T> where T : new()
7
{
8
    public T item = new T();      // 正确，因为 new() 约束保证有无参构造
9
}

三、委托和事件#

1. 委托（delegate）#

委托就是方法的”引用”，可以把方法当参数传递，类似 C 的函数指针但类型安全。

1
// 声明委托类型
2
delegate void MyDelegate(string msg);
3

4
void SayHello(string msg) => Console.WriteLine($"Hello, {msg}");
5

6
// 使用
7
MyDelegate d = SayHello;
8
d("World");   // → Hello, World

多播委托（一个委托调多个方法）：

1
void Method1(string m) => Console.WriteLine($"M1: {m}");
2
void Method2(string m) => Console.WriteLine($"M2: {m}");
3

4
MyDelegate d = Method1;
5
d += Method2;          // 添加
6
d("Hi");               // → M1: Hi  \n  M2: Hi
7
d -= Method1;          // 移除

坑：多播委托若没赋值直接调用会 NullReferenceException，用 ?.Invoke()：

1
MyDelegate d = null;
2
// d("x");            // NullReferenceException
3
d?.Invoke("x");       // 安全，null 时不调用

2. 内置委托类型#

C# 内置了三种常用委托，省得自己声明。

1
// Action：无返回值（最多 16 个参数）
2
Action<string> log = msg => Console.WriteLine(msg);
3
log("hi");                         // → hi
4

5
// Func：有返回值（最后一个参数是返回类型）
6
Func<int, int> square = x => x * x;
7
Console.WriteLine(square(5));      // → 25
8

9
Func<int, int, int> add = (a, b) => a + b;
10
Console.WriteLine(add(3, 4));      // → 7
11

12
// Predicate：返回 bool，常用作查找条件
13
Predicate<int> isEven = n => n % 2 == 0;
14
Console.WriteLine(isEven(4));      // → True

3. Lambda 表达式#

=> 读作”goes to”，是匿名方法的简写。

1
// 表达式形式
2
Func<int, int> square = x => x * x;
3

4
// 语句块形式
5
Func<int, int> abs = x =>
6
{
7
    if (x < 0) return -x;
8
    return x;
9
};
10

11
// 在集合方法中使用
12
List<int> nums = new List<int> { 3, 8, 1, 6, 9 };
13
int firstBig = nums.Find(x => x > 5);          // → 8
14
List<int> bigs = nums.FindAll(x => x > 5);     // → [8, 6, 9]

4. 事件（event）#

事件是特殊的委托，限制外部只能 += 和 -=，不能直接赋值或触发，更安全。

1
class Button
2
{
3
    // 声明事件
4
    public event EventHandler OnClick;
5

6
    public void Click()
7
    {
8
        Console.WriteLine("按钮被点击");
9
        // 触发事件（用 ?.Invoke 防止无订阅者）
10
        OnClick?.Invoke(this, EventArgs.Empty);
11
    }
12
}
13

14
// 使用
15
Button btn = new Button();
16
btn.OnClick += (sender, e) => Console.WriteLine("处理点击 1");
17
btn.OnClick += (sender, e) => Console.WriteLine("处理点击 2");
18
btn.Click();
19
// 输出：
20
// 按钮被点击
21
// 处理点击 1
22
// 处理点击 2
23

24
// btn.OnClick = null;     // 编译错误！事件外部不能赋值
25
// btn.OnClick(this, ..);  // 编译错误！事件外部不能触发

vs 委托： 事件更安全，外部不能随意触发或清空。

坑：忘记取消订阅可能导致内存泄漏（订阅者被事件持有，无法被 GC 回收）：

1
// 在对象销毁前应取消订阅
2
btn.OnClick -= handler;

四、LINQ（Language Integrated Query）#

LINQ 让你像写 SQL 一样查询各种数据源。

1. 查询语法#

1
List<int> nums = new List<int> { 3, 8, 1, 6, 9, 2 };
2

3
var result = from x in nums
4
             where x > 5
5
             orderby x
6
             select x;
7

8
foreach (var n in result) Console.WriteLine(n);   // 6 8 9

2. 方法语法（更常用）#

1
// 过滤
2
var bigs = nums.Where(x => x > 5);                 // [8, 6, 9]
3

4
// 投影
5
var doubled = nums.Select(x => x * 2);             // [6,16,2,12,18,4]
6

7
// 排序
8
var asc = nums.OrderBy(x => x);                    // 1,2,3,6,8,9
9
var desc = nums.OrderByDescending(x => x);         // 9,8,6,3,2,1
10

11
// 取第一个
12
int first = nums.First(x => x > 5);                // 8（找不到抛异常）
13
int firstOr = nums.FirstOrDefault(x => x > 100);   // 0（找不到返回默认值）
14

15
// 判断
16
bool anyBig = nums.Any(x => x > 5);                // True
17
bool allBig = nums.All(x => x > 0);                // True
18
int count = nums.Count(x => x > 5);                // 3
19

20
// 聚合
21
int sum = nums.Sum();                              // 29
22
int max = nums.Max();                              // 9
23
int min = nums.Min();                              // 1
24
double avg = nums.Average();                       // 4.833...
25

26
// 去重 / 截取 / 分组
27
var distinct = nums.Distinct();
28
var top3 = nums.OrderByDescending(x => x).Take(3);  // 取前 3 大
29
var skip2 = nums.Skip(2);                            // 跳过前 2 个
30
var grouped = nums.GroupBy(x => x % 2);              // 按奇偶分组

3. 综合示例#

1
class Student
2
{
3
    public string Name { get; set; }
4
    public int Score { get; set; }
5
}
6

7
List<Student> students = new List<Student>
8
{
9
    new Student { Name = "小明", Score = 85 },
10
    new Student { Name = "小红", Score = 92 },
11
    new Student { Name = "小刚", Score = 78 },
12
    new Student { Name = "小华", Score = 92 },
13
};
14

15
// 查分数大于 80 的学生，按分数降序，取名字
16
var topNames = students
17
    .Where(s => s.Score > 80)
18
    .OrderByDescending(s => s.Score)
19
    .ThenBy(s => s.Name)
20
    .Select(s => s.Name)
21
    .ToList();
22

23
// topNames → ["小红", "小华", "小明"]

4. 坑#

LINQ 是延迟执行的，只有在 ToList()、ToArray()、foreach 等真正取值时才执行：

1
var query = nums.Where(x => { Console.WriteLine($"检查 {x}"); return x > 5; });
2
// 此时还没输出，因为 query 还没被消费
3
var list = query.ToList();   // 此时才输出"检查 ..."

五、多线程#

1. Thread（传统线程）#

1
Thread t = new Thread(() =>
2
{
3
    for (int i = 0; i < 3; i++) Console.WriteLine($"工作线程: {i}");
4
});
5
t.Start();
6
t.Join();   // 等待线程结束
7
Console.WriteLine("主线程结束");

坑：线程不能直接访问 UI 控件（WinForm/WPF 中要用 Control.Invoke 或 Dispatcher.Invoke）。

2. Task（推荐）#

基于线程池，比 Thread 更轻量、更好管理。

1
// 启动任务
2
Task task = Task.Run(() =>
3
{
4
    Console.WriteLine("Task 执行中");
5
});
6

7
// 带返回值
8
Task<int> task2 = Task.Run(() => 42);
9
int result = task2.Result;   // 阻塞等结果 → 42
10

11
// 延续任务
12
Task.Run(() => 1)
13
    .ContinueWith(t => Console.WriteLine(t.Result + 1));   // → 2

3. async/await（推荐）#

异步编程的现代写法，代码看起来像同步，但不会阻塞线程。

1
async Task<string> DownloadAsync()
2
{
3
    await Task.Delay(1000);          // 模拟耗时操作
4
    return "下载完成";
5
}
6

7
async Task DoWork()
8
{
9
    Console.WriteLine("开始");
10
    string data = await DownloadAsync();
11
    Console.WriteLine(data);          // → 下载完成
12
    Console.WriteLine("结束");
13
}

规则：

async 方法必须至少有一个 await（否则编译警告）
返回类型一般是 Task 或 Task<T>，事件处理器可用 async void

坑 1： async void 只能用于事件处理器，其他场景用 async Task（异常无法捕获、无法等待）。

坑 2： await 只能在 async 方法中使用：

1
// void Wrong() { await Task.Delay(100); }   // 编译错误
2
async Task Right() { await Task.Delay(100); }

坑 3： 不要用 .Result 或 .Wait() 等 async 方法，会死锁，要用 await。

4. 并发问题#

多线程访问共享数据要加锁。

1
int counter = 0;
2
object locker = new object();
3

4
// 不加锁：结果可能不是 2000000
5
for (int i = 0; i < 2; i++)
6
{
7
    Task.Run(() =>
8
    {
9
        for (int j = 0; j < 1000000; j++)
10
        {
11
            lock (locker)   // 临界区，同一时刻只能一个线程进入
12
            {
13
                counter++;
14
            }
15
        }
16
    });
17
}

5. Parallel 和 PLINQ（简述）#

1
// 并行执行循环
2
Parallel.For(0, 10, i =>
3
{
4
    Console.WriteLine($"处理 {i}");
5
});
6

7
// PLINQ：让 LINQ 并行执行
8
var result = Enumerable.Range(0, 1000)
9
    .AsParallel()
10
    .Where(x => x % 2 == 0)
11
    .ToList();

六、反射和特性#

1. 反射#

反射让你在运行时获取类型信息、创建对象、调用方法——非常强大但性能较低。

1
class Person
2
{
3
    public string Name;
4
    public int Age;
5
    public void SayHi() => Console.WriteLine($"Hi, I'm {Name}");
6
}
7

8
// 获取 Type
9
Type t = typeof(Person);
10
// 或：Type t = new Person().GetType();
11

12
// 获取字段
13
foreach (var f in t.GetFields())
14
    Console.WriteLine($"字段: {f.Name}");   // 字段: Name  字段: Age
15

16
// 获取方法
17
foreach (var m in t.GetMethods())
18
    Console.WriteLine($"方法: {m.Name}");
19

20
// 创建对象
21
object obj = Activator.CreateInstance(t);
22
// 给字段赋值
23
t.GetField("Name").SetValue(obj, "小明");
24
// 调用方法
25
t.GetMethod("SayHi").Invoke(obj, null);   // → Hi, I'm 小明

2. 特性（Attribute）#

特性是给代码元素加的”标签”，运行时通过反射读取。

内置特性：

1
[Obsolete("请使用 NewMethod()", error: false)]
2
void OldMethod() { }
3
// 调用 OldMethod 会编译警告

自定义特性：

1
// 1. 定义特性
2
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
3
class MyAttribute : Attribute
4
{
5
    public string Description { get; set; }
6
    public MyAttribute(string desc) { Description = desc; }
7
}
8

9
// 2. 使用特性
10
[My("这是一个测试类")]
11
class TestClass
12
{
13
    [My("测试方法")]
14
    public void DoWork() { }
15
}
16

17
// 3. 通过反射读取特性
18
Type type = typeof(TestClass);
19
object[] attrs = type.GetCustomAttributes(typeof(MyAttribute), false);
20
foreach (MyAttribute attr in attrs)
21
{
22
    Console.WriteLine(attr.Description);   // → 这是一个测试类
23
}

七、文件操作（IO）#

1. File 类#

1
// 写
2
File.WriteAllText("test.txt", "你好\n世界");
3
File.WriteAllLines("lines.txt", new[] { "第一行", "第二行" });
4

5
// 读
6
string content = File.ReadAllText("test.txt");   // → "你好\n世界"
7
string[] lines = File.ReadAllLines("lines.txt"); // → ["第一行", "第二行"]
8

9
// 判断
10
bool exists = File.Exists("test.txt");   // → True
11
File.Delete("test.txt");

2. Directory 类#

1
Directory.CreateDirectory("MyDir");
2
bool exists = Directory.Exists("MyDir");
3
string[] files = Directory.GetFiles("MyDir", "*.txt");   // 获取目录下文件
4
Directory.Delete("MyDir", recursive: true);              // 递归删除

3. Path 类#

1
string full = Path.Combine("folder", "sub", "file.txt");  // → folder\sub\file.txt
2
string name = Path.GetFileName(@"C:\a\b.txt");            // → b.txt
3
string ext = Path.GetExtension(@"C:\a\b.txt");            // → .txt
4
string dir = Path.GetDirectoryName(@"C:\a\b.txt");        // → C:\a

4. StreamReader / StreamWriter#

流式读写，适合大文件。

1
// 写
2
using (StreamWriter sw = new StreamWriter("log.txt"))
3
{
4
    sw.WriteLine("第一行");
5
    sw.WriteLine("第二行");
6
}
7

8
// 读
9
using (StreamReader sr = new StreamReader("log.txt"))
10
{
11
    string line;
12
    while ((line = sr.ReadLine()) != null)
13
        Console.WriteLine(line);
14
}

坑：流用完必须释放，用 using 自动调用 Dispose，否则文件被占用。

八、高级排序#

1. 插入排序#

思想： 把每个元素插入到前面已排好的部分中的正确位置（像整理扑克牌）。

时间复杂度 O(n²)，但对接近有序的数据效率很高（接近 O(n)）。

1
void InsertionSort(int[] arr)
2
{
3
    for (int i = 1; i < arr.Length; i++)
4
    {
5
        int key = arr[i];
6
        int j = i - 1;
7
        while (j >= 0 && arr[j] > key)
8
        {
9
            arr[j + 1] = arr[j];
10
            j--;
11
        }
12
        arr[j + 1] = key;
13
    }
14
}
15

16
int[] a = { 5, 2, 8, 1, 9 };
17
InsertionSort(a);
18
Console.WriteLine(string.Join(", ", a));   // → 1, 2, 5, 8, 9

2. 希尔排序#

思想： 分组插入排序，逐步缩小间隔 gap，是插入排序的改进版。

时间复杂度约 O(n^1.3)，比直接插入快很多。

1
void ShellSort(int[] arr)
2
{
3
    int n = arr.Length;
4
    for (int gap = n / 2; gap > 0; gap /= 2)
5
    {
6
        for (int i = gap; i < n; i++)
7
        {
8
            int key = arr[i];
9
            int j = i;
10
            while (j >= gap && arr[j - gap] > key)
11
            {
12
                arr[j] = arr[j - gap];
13
                j -= gap;
14
            }
15
            arr[j] = key;
16
        }
17
    }
18
}
19

20
int[] a = { 8, 1, 4, 9, 6, 3, 5, 2, 7, 0 };
21
ShellSort(a);
22
Console.WriteLine(string.Join(", ", a));   // → 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

3. 快速排序#

思想： 选一个基准值 pivot，比它小的放左边，大的放右边，递归处理两边。

平均 O(n log n)，最坏 O(n²)（已排序数据 + 选首元素为基准时）。

1
void QuickSort(int[] arr, int left, int right)
2
{
3
    if (left >= right) return;
4

5
    int pivot = arr[left];
6
    int i = left, j = right;
7
    while (i < j)
8
    {
9
        while (i < j && arr[j] >= pivot) j--;
10
        arr[i] = arr[j];
11
        while (i < j && arr[i] <= pivot) i++;
12
        arr[j] = arr[i];
13
    }
14
    arr[i] = pivot;
15

16
    QuickSort(arr, left, i - 1);
17
    QuickSort(arr, i + 1, right);
18
}
19

20
int[] a = { 6, 2, 8, 1, 9, 3 };
21
QuickSort(a, 0, a.Length - 1);
22
Console.WriteLine(string.Join(", ", a));   // → 1, 2, 3, 6, 8, 9

4. 归并排序#

思想： 分治法，分成两半分别排序，再把两个有序子数组合并。

稳定排序，时间复杂度始终 O(n log n)，需要额外 O(n) 空间。

1
void MergeSort(int[] arr, int left, int right)
2
{
3
    if (left >= right) return;
4
    int mid = (left + right) / 2;
5
    MergeSort(arr, left, mid);
6
    MergeSort(arr, mid + 1, right);
7
    Merge(arr, left, mid, right);
8
}
9

10
void Merge(int[] arr, int left, int mid, int right)
11
{
12
    int[] temp = new int[right - left + 1];
13
    int i = left, j = mid + 1, k = 0;
14
    while (i <= mid && j <= right)
15
    {
16
        if (arr[i] <= arr[j]) temp[k++] = arr[i++];
17
        else temp[k++] = arr[j++];
18
    }
19
    while (i <= mid) temp[k++] = arr[i++];
20
    while (j <= right) temp[k++] = arr[j++];
21
    for (int t = 0; t < temp.Length; t++)
22
        arr[left + t] = temp[t];
23
}
24

25
int[] a = { 7, 4, 2, 9, 1, 5 };
26
MergeSort(a, 0, a.Length - 1);
27
Console.WriteLine(string.Join(", ", a));   // → 1, 2, 4, 5, 7, 9

5. 排序算法对比表#

算法	平均时间	最坏时间	空间复杂度	稳定性	特点
冒泡	O(n²)	O(n²)	O(1)	稳定	最简单，效率最低
选择	O(n²)	O(n²)	O(1)	不稳定	交换次数少
插入	O(n²)	O(n²)	O(1)	稳定	对接近有序数据高效
希尔	O(n^1.3)	O(n²)	O(1)	不稳定	插入排序改进
快速	O(n log n)	O(n²)	O(log n)	不稳定	实际最快，常用
归并	O(n log n)	O(n log n)	O(n)	稳定	稳定且最坏也是 O(n log n)

稳定指相等元素排序后相对顺序不变。

九、其他重要概念#

1. 装箱和拆箱#

1
// 装箱：值类型 → object（在堆上创建副本）
2
int x = 5;
3
object o = x;       // 装箱
4

5
// 拆箱：object → 值类型
6
int n = (int)o;     // 拆箱 → 5
7

8
// 装拆箱的性能陷阱
9
ArrayList list = new ArrayList();
10
for (int i = 0; i < 1000; i++)
11
    list.Add(i);    // 每次都装箱！
12
// 用 List<int> 替代，避免装箱

2. 可空类型（Nullable）#

让值类型也能为 null，常用于数据库字段、未初始化状态。

1
int? x = null;              // int? 等价于 Nullable<int>
2
Console.WriteLine(x.HasValue);   // → False
3
// Console.WriteLine(x.Value);   // 抛 InvalidOperationException
4

5
int? y = 10;
6
Console.WriteLine(y.Value);      // → 10
7

8
// 空合并运算符 ??：null 时用默认值
9
int z = x ?? 0;                  // → 0
10
int w = y ?? 0;                  // → 10

3. 元组#

轻量级数据组合，不用专门定义类。

1
// 匿名元组
2
(int, string) pair = (1, "hello");
3
Console.WriteLine(pair.Item1);   // → 1
4
Console.WriteLine(pair.Item2);   // → hello
5

6
// 命名元组（推荐）
7
(int id, string name) p = (1, "小明");
8
Console.WriteLine(p.id);         // → 1
9
Console.WriteLine(p.name);       // → 小明
10

11
// 方法返回多个值
12
(string, int) GetInfo() => ("小明", 18);
13
var info = GetInfo();
14
Console.WriteLine($"{info.Item1} {info.Item2}岁");   // → 小明 18岁

4. 模式匹配（C# 7.0+）#

1
// is 类型匹配
2
object obj = 42;
3
if (obj is int n && n > 0)
4
{
5
    Console.WriteLine($"正整数: {n}");   // → 正整数: 42
6
}
7

8
// switch 表达式（C# 8.0+）
9
string GetLevel(int score) => score switch
10
{
11
    >= 90 => "优秀",
12
    >= 80 => "良好",
13
    >= 60 => "及格",
14
    _     => "不及格"
15
};
16
Console.WriteLine(GetLevel(85));   // → 良好

5. record 类型（C# 9.0+）#

不可变数据类型，自动生成 Equals、GetHashCode、ToString，特别适合做数据传输对象 (DTO)。

1
record Person(string Name, int Age);
2

3
var p1 = new Person("小明", 20);
4
var p2 = new Person("小明", 20);
5
Console.WriteLine(p1 == p2);          // → True（基于值比较，普通类会是 False）
6
Console.WriteLine(p1);                // → Person { Name = 小明, Age = 20 }
7

8
// with 表达式：基于原对象创建副本，修改部分字段
9
var p3 = p1 with { Age = 21 };
10
Console.WriteLine(p3.Age);            // → 21
11
Console.WriteLine(p1.Age);            // → 20（原对象不变）

顶级篇总结#

每个知识点一句话总结#

集合：List 动态数组、Dictionary 键值查找、Queue/Stack 各管 FIFO/LIFO、HashSet 去重
泛型：类型安全 + 避免装箱 + 代码复用，约束限定 T 的能力
委托：方法的引用，多播委托可一调多，用 ?.Invoke() 防 null
事件：受限的委托，外部只能订阅不能触发，记得取消订阅防泄漏
LINQ：查询语法 + 方法语法，延迟执行，ToList() 才真正执行
多线程：Task + async/await 是现代首选，共享数据要加 lock
反射：运行时探查类型，特性是可被反射读取的标签
文件 IO：File/Directory/Path 够用，大文件用流，记得 using
排序：插入适合近似有序，希尔分组，快排最快，归并稳定
其他：装箱拆箱有开销用泛型避免，可空类型处理空值，元组返回多值，record 做不可变数据

学习建议#

多写代码：每个 API 都亲手跑一遍，看输出和文档对得上
理解原理：委托不只是语法糖，理解它和事件的发布订阅模式
小项目练手：写一个任务管理器、文件搜索工具、爬虫，把集合、LINQ、多线程、IO 全用上
看官方文档：Microsoft Learn 是最权威的

音乐

音乐

C#学习【高级篇】