差别

这里会显示出您选择的修订版和当前版本之间的差别。

--- csharp:装箱与拆箱 [2025/11/24 17:05] – [32-3: 为什么要注意性能？] 张叶安
+++ csharp:装箱与拆箱 [2025/11/24 17:09] (当前版本) – 张叶安
@@ 行 1: / 行 1: @@
-====== 32：装箱与拆箱 (Boxing & Unboxing) ======
+====== 装箱与拆箱 (Boxing & Unboxing) ======
 在 C# 的统一类型系统中，所有类型（包括值类型）最终都继承自 `System.Object`。装箱和拆箱正是连接**值类型**和**引用类型**的桥梁。
@@ 行 11: / 行 11: @@
-===== 32-1: 概念定义 =====
+===== 1: 概念定义 =====
 C# 中的数据类型分为两类：
@@ 行 27: / 行 27: @@
   * **语法**：必须是**显式**的（需要强制转换符）。
-===== 32-2: 代码案例 =====
+===== 2: 代码案例 =====
 <code csharp>
@@ 行 72: / 行 72: @@
 </code>
-===== 32-3: 为什么要注意性能？ =====
+===== 3: 为什么要注意性能？ =====
 很多初学者容易忽略装箱拆箱带来的隐形开销。
@@ 行 109: / 行 109: @@
 </code>
-===== 32-4: 总结图解 =====
+===== 4: 总结图解 =====
 为了区分“入栈/出栈”与“装箱/拆箱”：
@@ 行 115: / 行 115: @@
   * **入栈/出栈**：是**代码执行流程**的管理。方法调用时，局部变量入栈；方法结束，栈帧销毁（出栈）。这是极快的 CPU 指令操作。
   * **装箱/拆箱**：是**数据存储位置**的搬运。涉及在 堆(Heap) 上动态找空地、分配内存、复制数据。这涉及到内存管理器和垃圾回收器 (GC)，速度慢得多。
+====== 5. 深度对比：装箱/拆箱 vs 入栈/出栈 ======
+很多初学者容易混淆这两个概念，因为它们都涉及内存操作。但它们的本质完全不同：
+*   **入栈/出栈 (Push/Pop)**：是**方法的生命周期**。涉及**栈 (Stack)**。速度极快，由 CPU 指令直接管理。
+*   **装箱/拆箱 (Box/Unbox)**：是**数据的类型转换**。涉及**堆 (Heap)**。速度较慢，涉及内存分配和垃圾回收 (GC)。
+===== 1. 对比案例代码 =====
+我们来看一个具体的 C# 方法调用过程。
+<code csharp>
+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 方法结束 -> 出栈
+}
+</code>
+===== 2. 详细执行流程分析 =====
+我们将上述代码的执行拆解为微观步骤，对比两种操作的区别。
+^ 步骤 ^ 代码位置 ^ 操作类型 ^ 内存行为详解 ^
+| **1** | `Run()` 方法开始 | **入栈 (Push)** | 系统为 `Run` 方法分配一个“栈帧 (Stack Frame)”。<br>此时栈内存增长。 |
+| **2** | `int x = 10;` | **栈内存分配** | 在 `Run` 的栈帧中，划分 4 字节空间存储 `10`。<br>**注意：这里没有装箱，也没有堆内存分配。** |
+| **3** | `DoWork(x)` 调用 | **入栈 (Push)** | CPU 跳转到 `DoWork`，为其分配新的栈帧。<br>参数 `value` 被压入这个新栈帧中。 |
+| **4** | `object obj = value;` | **装箱 (Boxing)** | 1. 在 **堆 (Heap)** 上申请新内存。<br>2. 将栈上的 `10` **复制** 到堆中。<br>3. 栈上的变量 `obj` 存储堆地址。<br>**代价：高 (涉及 GC)。** |
+| **5** | `int y = (int)obj;` | **拆箱 (Unboxing)** | 1. 检查堆上的对象是否是 int。<br>2. 将堆上的 `10` **复制** 回栈上的变量 `y`。<br>**代价：中。** |
+| **6** | `DoWork` 结束 | **出栈 (Pop)** | `DoWork` 的栈帧被销毁。局部变量 `value`, `obj`, `y` 瞬间消失。<br>**注意：堆上那个装箱出来的对象还在，等待 GC 回收。** |
+| **7** | `Run` 结束 | **出栈 (Pop)** | `Run` 的栈帧被销毁。 |
+===== 3. 内存模型图解 =====
+为了更直观地理解，我们可以想象内存的快照。
+**当代码执行到 `[C] 装箱` 和 `[D] 拆箱` 之间时：**
+<code text>
+  【 栈内存 (Stack) 】                       【 堆内存 (Heap) 】
++--------------------------+                +---------------------+
+| [栈帧: DoWork]           |                |                     |
+|  int value = 10          |                | [装箱对象 Boxed Int]|
+|  object obj  ------------|--------------> |  类型: System.Int32 |
+|  int y       = 10        | <---(复制)---- |  值:   10           |
++--------------------------+                +---------------------+
+| [栈帧: Run]              |                ^
+|  int x = 10              |                |
++--------------------------+                |
+                                      (装箱产生的新对象)
+                                      (出栈后不会立即消失，需GC回收)
+</code>
+===== 4. 核心区别总结 =====
+| 特性 | 入栈 / 出栈 (Stack Push/Pop) | 装箱 / 拆箱 (Boxing/Unboxing) |
+| :--- | :--- | :--- |
+| **触发时机** | 方法调用开始 / 方法调用结束 | 值类型与引用类型互相转换时 |
+| **内存区域** | 仅涉及 **栈 (Stack)** | 涉及 **堆 (Heap)** 和 栈 |
+| **速度** | **极快** (CPU 指针移动) | **较慢** (内存分配、数据复制) |
+| **垃圾回收** | **无** (自动随作用域销毁) | **有** (装箱会在堆上产生垃圾，增加 GC 负担) |
+| **开发建议** | 正常编程逻辑，无法避免 | **应尽量避免** (使用泛型、ToString等优化) |
+**一句话总结：**
+“入栈出栈”是程序跑得通的基础（像走路迈腿）；
+“装箱拆箱”是数据搬家的过程（像把东西从口袋拿出来放到仓库里，再拿回来），搬家是累人的，所以要少搬。

Detach Close

您访问的页面并不存在。如果允许，您可以使用创建该页面按钮来创建它。

差别

该主题尚不存在

张叶安的博客