【层面一】C#语言基础和核心语法-03(泛型/集合/LINQ)

1.泛型（Generics）

1.1 为什么需要泛型？

在泛型出现之前，我们主要用两种方式来编写“通用”的代码，但它们都有巨大的缺陷。

1. 方式一：针对具体类型 - 重复的代码

假设我们需要一个能存放整数的盒子和一个能存放字符串的盒子：

public class IntBox
{
    public int Data { get; set; }
}

public class StringBox
{
    public string Data { get; set; }
}

// ... 还需要 BoolBox, PersonBox, 无穷无尽...

问题：代码重复。IntBox 和 StringBox 的逻辑完全一样，只是因为要存储的数据类型不同，我们就得写无数个几乎一模一样的类。这是维护的噩梦。

2. 方式二：使用 object 类型 - 性能与安全性的灾难

为了解决重复问题，我们想到了 .NET 所有类型的基类：object。

public class ObjectBox
{
    public object Data { get; set; }
}

// 使用
ObjectBox box1 = new ObjectBox();
box1.Data = 100; // 装箱（Boxing）发生！int 被包裹成 object

ObjectBox box2 = new ObjectBox();
box2.Data = "Hello";

// 取数据时，必须进行强制类型转换（Unboxing）
int myInt = (int)box1.Data; // 拆箱，正确
string myString = (string)box2.Data; // 正确

// 但这是不安全的！
int crash = (int)box2.Data; // 编译通过，但运行时会抛出 InvalidCastException！

这种方式有两个致命缺点：

1. 性能损耗：存储值类型（如 int）时会发生装箱（Boxing） 和拆箱（Unboxing） 操作，这是一个昂贵的性能开销。
2. **类型不安全：**编译器无法检查强制类型转换是否有效，错误只能在运行时暴露，极易导致程序崩溃。

1.2 泛型的救世主思维：“类型参数化”

泛型的思路非常直观：既然逻辑是一样的，只是数据类型不同，那我们为什么不把‘类型’本身也作为一个参数呢？

就像是一个万能模具。

• 没有泛型：你需要为生产“塑料猫”、“塑料狗”、“塑料汽车”分别制造一个专用的模具。
• 有了泛型：你只需要一个万能模具。使用时，你告诉它：“用塑料” -> 得到塑料猫；“用金属” -> 得到金属猫。“塑料”和“金属”就是类型参数。

这个万能模具，就是泛型类。而“塑料”、“金属”，就是类型参数 T。

1.3 泛型的本质与原理

1. 它是如何工作的？- 运行时支持

泛型并非 C# 语言的“语法糖”。它是 CLR（公共语言运行时）的内置功能，其本质是：在运行时根据需要动态生成具体的类型。

• 当你定义泛型时：List
  CLR 并不会立即创建一个真正的类型。它只是记住这个蓝图：“有一个列表，它的元素类型是 T”。

• 当你使用泛型时：

  List<int> intList = new List<int>();
  List<string> stringList = new List<string>();

  • CLR 遇到 List：检查是否已生成过 int 版本的列表。如果没有，即时（JIT编译时） 地根据 List 的蓝图，生成一个专用于 int 的具体类型。这个新类型中的 T 被全部替换为 int。
  • 同理，它为 List 生成另一个专用于 string 的具体类型。

这个过程被称为“泛型类型实例化”。

2. 它带来的三大核心优势

   1. 类型安全：编译器在编译时就能进行严格的类型检查。
   List<int> list = new List<int>();
   list.Add(100); // ✅ 正确
   list.Add("Hello"); // ❌ 编译错误！编译器直接报错，无法通过。
   int num = list[0]; // ✅ 直接就是 int，不需要强制转换。

   2. 性能卓越：彻底消除了装箱和拆箱。
   • List 内部就是一个 int [ ] 数组。
   • Dictionary<string, int> 内部就是 string 和 int 的键值对。
   • 值类型直接存储，引用类型直接存储引用，没有任何性能损耗。
   3. 代码复用：一份泛型代码，可以用于无限多种数据类型。.NET 标准库中的 List, Dictionary<TKey, TValue>, Nullable 等都是最好的例子，我们无需为自己定义的每一种类型都重写一遍集合类。

1.4 如何使用泛型

1. 使用现有的泛型（消费者）
   这是我们最常做的角色。使用 System.Collections.Generic 命名空间下的泛型集合是入门第一步。

// 泛型列表
List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
string first = names[0]; // 类型安全，直接返回 string

// 泛型字典
Dictionary<int, string> employeeMap = new Dictionary<int, string>();
employeeMap.Add(1, "Alice");
employeeMap.Add(2, "Bob");
string employee = employeeMap[1]; // 类型安全

// 泛型方法（LINQ 中大量使用）
var numbers = new List<int> { 1, 2, 3, 4, 5 };
// Where<T> 和 ToList<T> 都是泛型方法，编译器通常能推断出 T 是 int
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();

2. 创建自己的泛型（生产者）

   1. 创建泛型类/接口/结构
      使用 语法来声明类型参数。

      // 定义一个自己的万能盒子
      public class MyBox<T> // T 是类型参数
      {
          public T Content { get; set; } // 使用 T 作为属性类型
      
          public bool IsContentEmpty()
          {
              // 我们可以把 T 当作一个已知类型来使用
              return Content == null || Content.Equals(default(T));
          }
      }
      
      // 使用
      MyBox<int> box1 = new MyBox<int> { Content = 100 };
      MyBox<string> box2 = new MyBox<string> { Content = "Hello" };
      MyBox<Person> box3 = new MyBox<Person> { Content = new Person() };

   2. 创建泛型方法
      即使类不是泛型的，方法也可以是泛型的。

      public class Utility
      {
          // 一个交换两个变量值的泛型方法
          public static void Swap<T>(ref T a, ref T b)
          {
              T temp = a;
              a = b;
              b = temp;
          }
      }
      
      // 使用
      int x = 10, y = 20;
      Utility.Swap(ref x, ref y); // 编译器推断出 T 是 int
      
      string s1 = "foo", s2 = "bar";
      Utility.Swap(ref s1, ref s2); // 编译器推断出 T 是 string

3. 添加约束（让泛型更“懂事”）
   默认情况下，T 是 object 类型，你只能调用 object 的方法（如 ToString()）。但我们可以通过 约束 来要求 T 必须满足某些条件，从而可以在泛型代码中调用更多特定的方法。

// 要求 T 必须是实现了 IComparable 接口的类型
// 这样我们就可以在方法里调用 a.CompareTo(b)
public T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

// 使用
int maxInt = Max(10, 20); // ✅ int 实现了 IComparable<int>
string maxStr = Max("A", "B"); // ✅ string 实现了 IComparable<string>
// Person maxPerson = Max(p1, p2); // ❌ 如果 Person 没实现 IComparable<Person>，编译就会报错！

常用约束：

• where T : struct：T 必须是值类型。
• where T : class：T 必须是引用类型。
• where T : new()：T 必须有一个无参构造函数（允许 new T()）。
• where T : SomeBaseClass：T 必须继承自某个基类。
• where T : ISomeInterface：T 必须实现某个接口。

1.5 高级主题：协变与逆变

这是泛型中更高级的概念，主要为了增加泛型接口和委托的灵活性。

• 协变（Out）：允许使用更派生的类型作为输出/返回值。

  • 用 out 关键字修饰类型参数（如 IEnumerable）。
  • IEnumerable 可以被赋值给 IEnumerable