# 1. JIT（Just-In-Time Compilation）
- **即时编译**：程序运行时，虚拟机（如 Mono VM、CLR）会把 **IL（中间语言）** 动态翻译为目标机器码。  
- **特点**：
  - 运行时才编译，启动时开销较小；  
  - 可以针对实际运行环境做优化；  
  - 支持 **动态类型生成** 和 **反射**；  
  - 每次执行需要耗时翻译，效率低于原生机器码。  

# 2. AOT（Ahead-Of-Time Compilation）
- **提前编译**：在程序构建阶段，编译器（如 IL2CPP + 平台 C++ 编译器）将 **IL 预先翻译为目标机器码**。  
- **特点**：
  - 启动时无需再翻译，执行效率高；  
  - 依赖平台 C++/本机编译器做优化；  
  - 不支持运行时动态生成代码，所有类型需在编译期可达；  
  - 构建时间较长，灵活性较低。  

# 3. JIT vs AOT 对比

![jit_vs_aot_comparison.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/c28ca17d759a7a4409a6169ea297c44a.jit_vs_aot_comparison.webp)


JIT和AOT

# Mono
## 1. Unity 和 Mono 的关系
-   **Unity 背景**：引擎底层主要由
    **C/C++** 实现。
-   **选择 Mono 的原因**：为降低上层逻辑开发门槛、扩大开发者群，Unity
    采用 **Mono** 作为上层脚本环境；Mono 同时具备 **跨平台** 与
    **跨语言** 特性，契合"一次开发，多平台运行"的目标。

## 2. Unity 跨平台的必备概念

### 2.1 Unity 的组成
-   **Unity Engine（引擎）**：提供 **UnityEngine.dll**；**C/C++**
    编写，含平台相关代码、图形 API、物理、灯光等底层能力。
-   **Unity Editor（编辑器）**：提供 **UnityEditor.dll**；主要 **C#**
    编写；早期支持 C#/JavaScript/Boo；**项目代码最终由 Mono 编译**。

### 2.2 回顾 Mono 的跨平台原理

-   基于 **CLI** 统一中间语言 **CIL**，再用 **CLR/Mono VM** 将 CIL
    转为目标 OS 的原生代码运行。

### 2.3 Mono 的主要构成

-   **C# 编译器（mcs）**；**Mono Runtime（虚拟机）**：含
    **JIT、AOT、GC、类库加载器**；**BCL 基础类库**；**Mono
    类库**（扩展功能用于不同 OS 应用构建）。

## 3. 跨平台的基本原理（Mono）

-   在 Unity 下使用多种语言实现逻辑，**发布时编译为 IL**；在对应 OS
    上通过 **Mono VM** 把 IL **翻译为机器码并运行**。

> 图 1：Unity + Mono 执行流程
> 
> ![unity_mono_flow.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/b160967b9b060052d9ed98ec645e28f7.unity_mono_flow.webp)

## 4. 基于 Mono 跨平台的优缺点

-   **优点**：只要在不同 OS 上实现 **Mono VM**，理论上可支持的平台
    **非常多**（接近"无限"）。
-   **缺点（补充说明）**：
    -   **维护成本**：Unity 升级需跟进 Mono 运行时与类库兼容；
    -   **特性滞后**：旧版 Mono 可能不支持最新 C#
        语法/运行时能力（在工程中需注意 API/编译目标选择）。

## 5. 与 .NET 生态的关系

-   **.NET Framework（2002）**：Windows 为主。
-   **Mono（2004）**：开源、跨平台，早期/至今都是 .NET
    的跨平台方案之一。
-   **.NET Core（2016）**：官方跨平台实现，后统一为现代 .NET。

> 图 2：Unity 组件与 Mono 的位置关系
> 
>![unity_components_mono.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/0ea86105b9d40b1eb51bfcf11f191791.unity_components_mono.webp)

# IL2CPP
## 1. IL2CPP 是什么
- **定义**：IL2CPP = **IL → C++** 的脚本后处理方式；将 C# 编译生成的 **IL** 转译成 **C++ 源码**，再由各平台 C++ 编译器生成本机机器码直接运行;
- **出现时间**：在 **Unity 4.6.1 p5** 之后加入，作为继 Mono 之后的新型跨平台方案。

## 2. IL2CPP 跨平台原理
- **核心流程**：**IL →（IL2CPP 转译为C++代码）→ C++ →（各平台 C++ 编译器 AOT提前编译为目标平台的机器码）→ 原生机器码 → IL2CPP VM（GC/线程/运行时服务）**。
- **要点**：
  - 借助各平台成熟的 C++ 编译器与优化链路，获得更高的运行效率与可移植性
  - 尽管中间形态变为 C++，但 **内存管理仍遵循 C# 的 GC 语义**；因此仍有 **IL2CPP VM** 承担 GC、线程等运行时服务。
> 图 3：IL2CPP 跨平台流程  
> ![il2cpp_note_il2cpp_flow.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/dd8eac3cb0902de828cb34a2e8f85fb2.il2cpp_note_il2cpp_flow.webp)

## 3.IL2CPP可能带来的问题
### 代码裁剪问题
> **IL2CPP在打包时会自动对Unity工程的DLL进行裁剪，将代码中没有引用到的类型裁剪掉，以达到减小发布后包的尺寸的目的;然而在实际使用过程中，很多类型有可能会被意外剪裁掉，造成运行时抛出找不到某个类型的异常。特别是通过反射等方式在编译时无法得知的函数调用，在运行时都很有可能遇到问题**

### 解决方案
1. IL2CPP处理模式时，将PlayerSetting->Other Setting->Managed Stripping Level(代码剥离)设置为Low，Disable: Mono模式下才能设置为不删除任何代码（但是没必要），IL2CPP模式下是一定会进行代码裁剪的，只不过是优先等级高低的问题，**但不推荐使用这种方式，这种方式还是不保守的不可控的，并不知道它会删除那些代码，优先使用方法2**
![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/ac5cf3a6432dc2a859f9436241df1f95.image.webp)
- Low:默认低级别，保守的删除代码，删除大多数无法访问的代码，同时也最大程度减少剥离实际使用的代码的可能性
- Medium:中等级别，不如低级别剥离谨慎，也不会达到高级别的极端
- Hight:高级别，尽可能多的删除无法访问的代码，有限优化尺寸减小。如果选择该模式一般需要配合link.xml使用

2. 通过Unity提供的link.xml方式来告诉Unity引擎，哪些类型是不能够被剪裁掉的，在Unity工程的Assets目录中（或其任何子目录中）建立一个叫link.xml（完全限定名字为link）的XML文件
    
内容示例：
```xml
<?xml version="1.0" encoding="UTF-8"?>
  
  
  <assembly fullname="UnityEngine" preserve="all"/>
  
  <assembly fullname="UnityEngine"/>

  
  <assembly fullname="Assembly-CSharp, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null">
    <type fullname="Assembly-CSharp.Foo" preserve="all"/>
  </assembly>

  
  <assembly fullname="Assembly-CSharp">
    
    <type fullname="MyGame.A" preserve="all"/>
    
    <type fullname="MyGame.B"/>
    
    <type fullname="MyGame.C" preserve="fields"/>
    
    <type fullname="MyGame.D" preserve="methods"/>
    
    <type fullname="MyGame.E" preserve="nothing"/>
    
    <type fullname="MyGame.F">
      
      <field signature="System.Int32 field1" />
      
      <field name="field2" />
      
      <method signature="System.Void Method1()" />
      
      <method signature="System.Void Method2(System.Int32,System.String)" />
      
      <method name="Method3" />

      
      
      <property signature="System.Int32 Property1" />
      <property signature="System.Int32 Property2" accessors="all" />
      
      <property signature="System.Int32 Property3" accessors="get" />
      
      <property signature="System.Int32 Property4" accessors="set" />
      
      <property name="Property5" />

      
      
      <event signature="System.EventHandler Event1" />
      
      <event name="Event2" />
    </type>

    
    <type fullname="MyGame.G`1">
      
      <field signature="System.Collections.Generic.List`1&lt;System.Int32&gt; field1" />
      <field signature="System.Collections.Generic.List`1&lt;T&gt; field2" />

      
      <method signature="System.Void Method1(System.Collections.Generic.List`1&lt;System.Int32&gt;)" />
      
      <event signature="System.EventHandler`1&lt;System.EventArgs&gt; Event1" />
    </type>


    
    <type fullname="MyGame.I" preserve="fields" required="0"/>

    
    <type fullname="MyGame.J" preserve="methods" required="0"/>

    
    <type fullname="MyGame.SomeNamespace*" />

    
    <type fullname="Prefix*" />

  </assembly>
</linker>
```

### 泛型问题
- IL2CPP和Mono最大的区别是 **不能在运行时动态生成代码和类型（反射）** ，IL2CPP 必须在编译阶段就把所有需要用到的泛型类型实例化好。如果在打包生成前某个泛型组合没有在代码中显式用过，编译器不会生成它的 C++ 对应实现，运行时就会报 “找不到方法/类型” 的错误；
- 举例： **`List<A>`和 `List<B>` 中A和B是我们自定义的类，我能必须在代码中显示的调用过，IL2CPP才能保留`List<A>`和`List<B>`两个类型。如果在热更新时我们调用`List<C>`，但是它之前并没有在代码中显示调用过，那么这时就会出现报错等问题。主要就是因为`JIT`和`AOT`两个编译模式的不同造成的**
 &rArr; [什么是JIT和AOT](https://xuxuxujs.cn/post/42)

### 解决方案
- 泛型类：随便声明一个类，然后在这个类中声明一些public的泛型类的变量（告诉IL2CPP这个泛型类被引用，被使用过了）
- 泛型方法：随便写一个静态方法，在将这个泛型方法在其中调用一下。这个静态方法无需被调用，这样做的目的其实就是在预言编译之前让IL2CPP知道我们需要使用这个内容；

# 两者差异（Mono&IL2CPP)
| 对比维度     | Mono（JIT 即时编译）                  | IL2CPP（AOT 提前编译）                  |
|--------------|--------------------------------------|-----------------------------------------|
| **打包速度** | 快 —— 直接生成 IL，打包流程简单       | 慢 —— 需 IL → C++ → 各平台编译 → 本机码 |
| **运行效率** | 慢 —— 运行时逐步翻译 IL，性能有损耗   | 快 —— 直接执行原生机器码，效率更高       |
| **灵活性**   | 高 —— 支持 JIT、反射、动态类型生成    | 低 —— 必须编译期确定类型，反射/泛型需预保留 |
| **平台支持** | 部分平台受限（如 WebGL、iOS 等）      | 跨平台兼容性更好，官方推荐用于正式发布   |
| **维护成本** | 高 —— 需要持续维护各平台 Mono VM      | 相对低 —— 借助各平台成熟 C++ 编译链路   |
| **适用场景** | 开发调试阶段、快速迭代                | 正式打包、上线发布，追求性能与兼容性     |

Unity跨平台原理解析

# .Net是什么
- **.NET 不是编程语言，也不是框架；是一整套技术体系/平台的统称或代号**。
- **包含内容**：
    -   框架体系：.NET Framework、.NET Core、Mono；
    -   开发语言：C#、VB、F#（C# 为主推）；
    -   开发工具：Visual Studio、Visual Studio Code。

**平台目标**
-   **跨语言**：不同 .NET 平台上的语言可无缝互操作。
-   **跨平台**：一次编译，应用可在任意有 .NET 框架实现的操作系统上运行。

# .Net跨语言的实现
在了解 .Net 如何实现跨语言之前要先了解三个概念，分别是CLS、CTS、CLI；
注意，一般我们所说的 .Net 平台的跨语言都是指面向 .Net 平台设计的语言，C#、VB.NET、F#类似这些语言中进行的。
## CLS
* **CLS（Common Language Specification，公共语言规范）**；微软在总结多种语言共性后提出的一组语言互操作规则；只要公开API遵守CLS，不同 .NET 语言即可互相调用；
* 并不是“全世界所有语言的通用规则”。它只定义在 .NET 平台内部，为了让面向 .NET 的语言（比如 C#、VB.NET、F# 等）能够互操作而设立的一组规则，如果一门语言不是针对 .NET 平台设计的，那么它不会去遵循 CLS。
## CTS
* **CTS（Common Type System，公共类型系统）**；当你需要设计面向 .Net 的语言时需要遵循一个体系，这个体系就是CTS，刚才提到的CLS公共语言规范就是是CTS公共类型系统的子级
* 消除“各语言类型体系不一致”带来的互操作障碍，确保所有 .NET 语言在类型与成员语义上说同一种“类型语言”
* 一个编程语言，如果它能够支持CTS，那么我们就称它为面向 .NET 平台的语言
## CLI
* **CLI（Common Language Infrastructure，公共语言基础结构）**；
* 微软提交给 ECMA 的工业标准，对 .NET 的关键组成（含 CTS 等）进行标准化；可理解为“让 .NET 语言与实现具备共同语义的标准底座”，以标准形式明确语言互操作与类型系统等基础规则，使不同实现（如 .NET Framework、Mono、.NET Core/现代 .NET）有统一的规范依据。
## 跨语言如何实现
* 微软为了实现跨语言，制定了一些规范，只要一门语言支持CTS（公共类型系统）的规则，那么我们就能够使用它在 .Net 平台下开发应用程序；
* CLS（公共语言规范）是CTS的一个子级，是一组语言互操作的标准规范，我们经常可以看到的CLI公共语言基础结构，它包含CTS公共类型系统，它是微软将CTS等内容提交给国际组织计算机制造联合会ECMA的一个工业标准

![dotnet_cross_language.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/34fbb258c97f1f31f1a08a8dd9cc8bc4.dotnet_cross_language.webp)

# .Net跨平台的实现
早期的 .NET（.NET Framework，2002）只服务于 Windows，它解决了跨语言的问题，但是并没有解决跨平台的问题，如果要让同一份 .NET 程序跑在不同操作系统，必须为不同平台实现对应的 CLR（公共语言运行时），那么这就涉及到以下三个核心的概念：
## .NetFramework
* **定位**：是一个可以快速开发、部署网站服务及应用程序的开发框架，是 Windows 中的一个组件，部分开源，主要用于开发Windows下应用程序；
* **特点**：包含 CLR：负责内存、线程管理，将 IL 翻译为 Windows下的 机器码；
* **局限**：只能在 Windows 上运行，不跨平台。
## Mono
* **定位**：.NET Framework 的第三方替代实现，由Xamarin主导，遵循CLI；
* **特点**：在不同操作系统实现对应 CLR，将语言生成的IL中间代码在不同操作系统下的CLR再翻译为机器码，使得实现跨平台，这是社区的实现
* **意义**：在 .NET Core 出现之前，Mono 是唯一的跨平台方案，Unity早期使用它作为脚本运行时。
## .NetCore
* **定位**：新一代 .NET，目标就是跨平台，
* **特点**：完全开源，为不同 OS 提供各自的 CLR，把 IL 翻译为本机码，做法和Mono类似，这完全由官方设计并重新实现

# 跨平台如何实现
1.  **统一编译产物**：所有 .NET 语言先编译为 IL（中间语言）+
    元数据，封装在程序集。
2.  **各平台实现 CLR**：不同操作系统安装对应
    CLR（Framework/Core/Mono），使 IL 能在本机上运行。
3.  **CLR 把 IL
    翻译成本机机器码**，并提供运行时服务（内存、线程、异常管理等）。
    
![dotnet_cross_platform.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/d49108a942f1523d4c735eba0080814b.dotnet_cross_platform.webp)

> 总结：**跨语言靠 IL 统一，跨平台靠各平台的 CLR 实现。**

.Net跨语言与跨平台原理解析

C#_async和await

# 对于值类型：
==和equals等价，都是比较存储信息的内容本身

# 对于引用类型：
==比较的是引用类型在栈中的地址，equals方法则比较的是引用类型在托管堆中的存储信息的内容