在 C# 的统一类型系统中，所有类型（包括值类型）最终都继承自 `System.Object`。装箱和拆箱正是连接值类型和引用类型的桥梁。

核心注意点：

• 不是入栈与出栈：虽然涉及栈内存，但装箱/拆箱特指类型转换和堆内存分配的过程，不同于函数调用时的栈帧操作。
• 性能警告：在实际开发中（尤其是高性能场景，如游戏循环、大量数据处理），应尽量避免装箱与拆箱操作，因为它们会带来显著的性能损耗。

C# 中的数据类型分为两类：

• 值类型 (Value Type)：如 `int`, `double`, `bool`, `struct`, `enum`。通常存储在栈 (Stack) 上。
• 引用类型 (Reference Type)：如 `object`, `string`, `class`, `interface`。通常存储在堆 (Heap) 上。

定义：将 值类型 转换为 引用类型 的过程。

• 过程：系统会在“堆 (Heap)”上申请一块新内存，将“栈”上的值复制到“堆”上，并返回指向该堆内存的引用。
• 语法：通常是隐式的（不需要强制转换符）。

定义：将 引用类型 转换为 值类型 的过程。

• 过程：检查引用对象是否包含正确的值类型，然后将值从“堆”复制回“栈”。
• 语法：必须是显式的（需要强制转换符）。

class Program
{
    static void Main(string[] args)
    {
        // --- 1. 装箱操作 (Boxing) ---
        int i = 123;      // i 是值类型，存在栈上
 
        // 将 int 赋值给 object (引用类型)
        // 此时发生“装箱”：
        // 1. 在堆上分配内存
        // 2. 将 123 复制到堆中
        // 3. obj 指向堆中的地址
        object obj = i;   
 
        Console.WriteLine("装箱完成");
 
 
        // --- 2. 拆箱操作 (Unboxing) ---
        // 将 object 转换回 int
        // 此时发生“拆箱”：
        // 1. 检查 obj 指向的堆内存是否真的是 int 类型
        // 2. 将堆中的 123 复制回栈上的变量 j
        int j = (int)obj; 
 
        Console.WriteLine("拆箱结果: " + j);
 
 
        // --- 3. 错误示范 (类型不匹配) ---
        try 
        {
            double d = (double)obj; // 运行时报错！
            // 虽然 obj 里存的是数字，但它是 int 装箱来的。
            // 拆箱时类型必须严格匹配，不能直接拆成 double。
        }
        catch (InvalidCastException e)
        {
            Console.WriteLine("拆箱失败：类型不匹配");
        }
    }
}

很多初学者容易忽略装箱拆箱带来的隐形开销。

常见的不经意装箱场景（应避免）：

1. 使用 `ArrayList` (老旧集合)：

// 糟糕的写法
ArrayList list = new ArrayList();
list.Add(10); // Add参数是 object，这里把 10 装箱了！
list.Add(20); // 又装箱一次！
 
int x = (int)list[0]; // 拆箱！

优化方案：使用泛型集合 `List<T>`。

// 推荐写法
List<int> list = new List<int>();
list.Add(10); // 不发生装箱，直接存 int

2. 字符串拼接：

int score = 99;
// String.Format 或 Console.WriteLine 接收 object 参数
// 这里 score 被装箱了
Console.WriteLine("Score: {0}", score); 
 
// 优化：先转成字符串 (虽然 ToString 内部也可能有开销，但通常优于装箱)
Console.WriteLine("Score: " + score.ToString());

为了区分“入栈/出栈”与“装箱/拆箱”：

• 入栈/出栈：是代码执行流程的管理。方法调用时，局部变量入栈；方法结束，栈帧销毁（出栈）。这是极快的 CPU 指令操作。
• 装箱/拆箱：是数据存储位置的搬运。涉及在 堆(Heap) 上动态找空地、分配内存、复制数据。这涉及到内存管理器和垃圾回收器 (GC)，速度慢得多。

很多初学者容易混淆这两个概念，因为它们都涉及内存操作。但它们的本质完全不同： * 入栈/出栈 (Push/Pop)：是方法的生命周期。涉及栈 (Stack)。速度极快，由 CPU 指令直接管理。 * 装箱/拆箱 (Box/Unbox)：是数据的类型转换。涉及堆 (Heap)。速度较慢，涉及内存分配和垃圾回收 (GC)。

我们来看一个具体的 C# 方法调用过程。

class CompareTest
{
    // 入口方法
    public void Run()
    {
        int x = 10;           // [A] 局部变量声明
        DoWork(x);            // [B] 方法调用 -> 入栈
    } // [E] Run 方法结束 -> 出栈
 
    // 工作方法
    public void DoWork(int value)
    {
        // 此时 value 已经在栈上（作为参数传入）
 
        object obj = value;   // [C] 赋值给 object -> 装箱 (Boxing)
 
        int y = (int)obj;     // [D] 强转回 int -> 拆箱 (Unboxing)
 
        Console.WriteLine(y);
    } // [E] DoWork 方法结束 -> 出栈
}

我们将上述代码的执行拆解为微观步骤，对比两种操作的区别。

为了更直观地理解，我们可以想象内存的快照。

当代码执行到 `[C] 装箱` 和 `[D] 拆箱` 之间时：

  【 栈内存 (Stack) 】                       【 堆内存 (Heap) 】
+--------------------------+                +---------------------+
| [栈帧: DoWork]           |                |                     |
|  int value = 10          |                | [装箱对象 Boxed Int]|
|  object obj  ------------|--------------> |  类型: System.Int32 |
|  int y       = 10        | <---(复制)---- |  值:   10           |
+--------------------------+                +---------------------+
| [栈帧: Run]              |                ^
|  int x = 10              |                |
+--------------------------+                |
                                      (装箱产生的新对象)
                                      (出栈后不会立即消失，需GC回收)

一句话总结： “入栈出栈”是程序跑得通的基础（像走路迈腿）； “装箱拆箱”是数据搬家的过程（像把东西从口袋拿出来放到仓库里，再拿回来），搬家是累人的，所以要少搬。