# GameEntry Class

在 GF 中，调用框架中组件有两种写法，比如在这里我们获取 UI 组件：

1. 通过 Runtime 获取

```csharp
UIComponent uiComponent = UnityGameFramework.Runtime.GameEntry.GetComponent<UIComponent>();
uiComponent.OpenUIForm("",this);
```

2. 封装为静态类，全局调用

```csharp
GameEntry.UI.OpenUIForm("",this);
```



两种方式都可以得到，但明显后者更快捷，GameEntry 的主要作用就是为了更方便的全局调用。

# 初始化

1. 分别创建三个脚本，命名为 `GameEntry`​，`GameEntry.Builtin`​，`GameEntry.Custom`​
   ​![QQ_1727026306505](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240923013157.png)​

	三个脚本分别代表 GameEntry 类的三个部分，下面来依次讲解他们的作用：

* **GameEntry**

  在这里调用组件初始化方法，将内置组件和自定义组件初始化，使用 `partial` ​关键字将 GameEntry 类进行拆分为三个部分

  ```c#
  using UnityEngine;
  using UnityGameFramework.Runtime;

  /// <summary>
  /// 游戏入口。
  /// </summary>
  public partial class GameEntry : MonoBehaviour
  {
      private void Start()
      {
          //初始化内置组件
          InitBuiltinComponents();
          //初始化自定义组件
          InitCustomComponents();
      }
  }
  ```

* **GameEntry.Builtin**

  用于初始化内部组件，将各个组件封装为静态的属性供外部调用，并提供一个初始化方法用于 GameEntry

  ```csharp
  using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;
  using UnityGameFramework.Runtime;

  public partial class GameEntry : MonoBehaviour
  {
      /// <summary>
      /// 获取游戏基础组件。
      /// </summary>
      public static BaseComponent Base
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取配置组件。
      /// </summary>
      public static ConfigComponent Config
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取数据结点组件。
      /// </summary>
      public static DataNodeComponent DataNode
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取数据表组件。
      /// </summary>
      public static DataTableComponent DataTable
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取调试组件。
      /// </summary>
      public static DebuggerComponent Debugger
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取下载组件。
      /// </summary>
      public static DownloadComponent Download
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取实体组件。
      /// </summary>
      public static EntityComponent Entity
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取事件组件。
      /// </summary>
      public static EventComponent Event
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取文件系统组件。
      /// </summary>
      public static FileSystemComponent FileSystem
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取有限状态机组件。
      /// </summary>
      public static FsmComponent Fsm
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取本地化组件。
      /// </summary>
      public static LocalizationComponent Localization
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取网络组件。
      /// </summary>
      public static NetworkComponent Network
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取对象池组件。
      /// </summary>
      public static ObjectPoolComponent ObjectPool
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取流程组件。
      /// </summary>
      public static ProcedureComponent Procedure
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取资源组件。
      /// </summary>
      public static ResourceComponent Resource
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取场景组件。
      /// </summary>
      public static SceneComponent Scene
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取配置组件。
      /// </summary>
      public static SettingComponent Setting
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取声音组件。
      /// </summary>
      public static SoundComponent Sound
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取界面组件。
      /// </summary>
      public static UIComponent UI
      {
          get;
          private set;
      }

      /// <summary>
      /// 获取网络组件。
      /// </summary>
      public static WebRequestComponent WebRequest
      {
          get;
          private set;
      }

      private static void InitBuiltinComponents()
      {
          Base = UnityGameFramework.Runtime.GameEntry.GetComponent<BaseComponent>();
          Config = UnityGameFramework.Runtime.GameEntry.GetComponent<ConfigComponent>();
          DataNode = UnityGameFramework.Runtime.GameEntry.GetComponent<DataNodeComponent>();
          DataTable = UnityGameFramework.Runtime.GameEntry.GetComponent<DataTableComponent>();
          Debugger = UnityGameFramework.Runtime.GameEntry.GetComponent<DebuggerComponent>();
          Download = UnityGameFramework.Runtime.GameEntry.GetComponent<DownloadComponent>();
          Entity = UnityGameFramework.Runtime.GameEntry.GetComponent<EntityComponent>();
          Event = UnityGameFramework.Runtime.GameEntry.GetComponent<EventComponent>();
          FileSystem = UnityGameFramework.Runtime.GameEntry.GetComponent<FileSystemComponent>();
          Fsm = UnityGameFramework.Runtime.GameEntry.GetComponent<FsmComponent>();
          Localization = UnityGameFramework.Runtime.GameEntry.GetComponent<LocalizationComponent>();
          Network = UnityGameFramework.Runtime.GameEntry.GetComponent<NetworkComponent>();
          ObjectPool = UnityGameFramework.Runtime.GameEntry.GetComponent<ObjectPoolComponent>();
          Procedure = UnityGameFramework.Runtime.GameEntry.GetComponent<ProcedureComponent>();
          Resource = UnityGameFramework.Runtime.GameEntry.GetComponent<ResourceComponent>();
          Scene = UnityGameFramework.Runtime.GameEntry.GetComponent<SceneComponent>();
          Setting = UnityGameFramework.Runtime.GameEntry.GetComponent<SettingComponent>();
          Sound = UnityGameFramework.Runtime.GameEntry.GetComponent<SoundComponent>();
          UI = UnityGameFramework.Runtime.GameEntry.GetComponent<UIComponent>();
          WebRequest = UnityGameFramework.Runtime.GameEntry.GetComponent<WebRequestComponent>();
          Debug.Log(">>>>>>初始化内置组件成功");
      }
  }
  ```

* **GameEntry.Custom**
  我们可以在这里扩展实现自己的组件并初始化

  ```csharp
  using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;

  public partial class GameEntry : MonoBehaviour
  {
      //自定义组件
      //>>>

      //初始化自定义组件
      private void InitCustomComponents()
      {
          Debug.Log(">>>>>>初始化自定义组件成功");
      }
  }
  ```

# 启动

完成脚本的准备后，为 GameFramework 创建一个父物体 `GF`​，并将 `GameEntry` ​挂载在物体上，启动 Unity
​![QQ_1727108774350](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240924002616.png)​

​![QQ_1727108807375](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240924002759.png)​

Consolo 窗口输出 log，所有组件初始化成功，至此准备工作完毕，进入游戏流程

GameFramework02_GameEntry游戏入口

# 前言

**GameFramework**一个基于Unity引擎的开源框架，封装了游戏开发中常用的模块，制定了一系列的游戏业务的代码规范，适合中大型的游戏开发。在此之前，如果你想要开发项目不知从何入手，没有一个循序渐进且规范的流程，学习并使用GF将大大提高开发效率，提高我们的一个代码思维；使用框架尤其对于新手而言，是一种约束和提升，比如在接入GF后，打开一个UI必须继承和实现接口，使用规定的方法打开，不能随心所欲的写代码，这正是框架发挥的作用的体现，面向接口编程，与引擎和各类方案进行解耦。

# **框架组成**

![20240403145812](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240403145812.png)
![20240405005049](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240405005049.png)



框架由两个部分组成，`GameFramework`和`Unity GameFramework`（一下简称`GF`和`UGF`）

> 1. GF是一个VS工程(.sln),它建立在UGF上层,框架中的基础逻辑的实现在这里，占据源码的大部分，以`.dll`形式存在，这个部分是与游戏引擎无关的，不依赖Unity
   ![20240405010134](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240405010134.png)
   
> 2. UGF是一个Unity项目(.meta，.prefab)，基于GF并对其扩展，为了能够直接使用Unity当中的类和组件；UGF中包含的`.Runtime`​和`.Editor`​是为了实现引擎版本的兼容性和工具面板，我们也可以在UGF中自定义实现一些组件。  
   ​![20240405010242](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240405010242.png)​

# 模块概述

&rArr; [GF官方介绍](https://gameframework.cn/document/)

# 源码替换

## 注意事项

**如果要替换源码，那么一定要在Github上下载UGF和GF两个部分，而不能去单独去官网下载v2020.05.31的** **​`.unitypackage`​**​ **的包，因为官网的是老版本，这会导致UGF的** **​`.dll`​**​ **和GF代码的版本不一致，导入后引发API不存在的问题，会产出以下报错，请一定去Github主页下载!**  
​![bea8ff376ba9475e1646ec1433e1eb27](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/bea8ff376ba9475e1646ec1433e1eb27.png)​

## 替换步骤

1. 在E大的Github主页下载GF和UGF，无论什么形式`gitclone`或`.zip`，下载好后，先将`UnityGameFramework`导入进Unity中
   ![QQ_1726196125885](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726196125885.png)
2. 删除`GameFramework`的`.dll`文件，删除后会出现报错，先不用管
   ![QQ_1726196285367](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726196285367.png)
   ![QQ_1726196382271](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726196382271.png)
3. 将`GameFramework`文件夹拖入`UnityGameFramework/Libraries`路径下
   ![QQ_1726196679129](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726196679129.png)
4. 在`GameFramework`​目录下新建一个同名的`AssemblyDefinition`​文件，并勾选`Allow unsafe code`​，Apply应用一下  
   ​![903ccd0aa9782747ddebd6dab363c462](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/903ccd0aa9782747ddebd6dab363c462.png)  
   ​![QQ_1726197987965](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726197987965.png)​
5. 将`Scripts/Editor`文件夹下的`UnityGameFramework.Editor`依赖于刚刚创建的asdf，点击Apply
   ![QQ_1726198649709](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726198649709.png)
6. 将`Scripts/Runtime`文件夹下`UnityGameFramework.Runtime`同时依赖，Apply后重新编译，报错消失，源码替换完毕！
   ![QQ_1726198718559](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726198718559.png)
   ![QQ_1726198802436](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/QQ_1726198802436.png)

# 完毕

* **完成以上,源码版本的GF框架就应用在你的项目中了**
* 在GF的官方教程前三章的教程中已经提供了如何入门的基本介绍,建议在学习之前之前先阅读完前三章的内容，然后再开始对后续框架各个模块的了解和学习 ⇒ [传送门](https://gameframework.cn/category/tutorial/)  
  ​![20240403173750](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/20240403173750.png)​

‍

GameFramework01_入门与源码替换

# AB包是什么
* 特定于平台的资产压缩包，有点类似压缩文件  
* 能够压缩的资产包括：模型、贴图、预设体、音效、材质球等等  

# AB包的作用
1. 减小安装包体积 —— 将资源按需拆分打包，避免所有资源都打进主包，减少初始安装包的大小；
2. 动态的按需加载与卸载，减少运行时的内存 —— 通过AssetBundle可以在运行时从本地或服务器加载资源，并在不用时卸载释放内存；
3. 热更新支持 —— 不需要重新打包整个应用，只需替换或下载新的AB包即可实现资源和脚本的更新

# 打包说明
## 1.勾选标记资源
选中资源，在它的Inspector窗口底部，可以将当前资源加入某个标签或新建一个标签，标签的名字就是AB包的名字，这里的包名是强制小写的

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


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

## 2.官方打包工具AssetBundle Browser
AB包打包工具可以通过编辑器扩展自己写一个，调用AB包相关的API即可。在这里我直接使用官方的省事；
### 面板参数讲解
1. Configure

    显示当前所有的标签和对应有哪些资源，如图，model包中包含一个Cube资源，一目了然
    ![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/ebe949419302912c13c458c13fe14689.image.webp)

2. Build  
    ![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/54c382392c9403d486d544bf9a2fa15e.image.webp)
    - BuildTarget:目标平台
    - Output Path:目标输出路径
    - Clear Folders：是否清空文件夹 重新打包
    - Copy To StreamingAssets：是否拷贝到StreamingAssets
    - Compression
    - NoCompression
        - 不压缩，解压快，包较大 不推荐
    - LZMA
        - 压缩最小，解压慢
        - 缺点：用一个资源 要解压所有
    - LZ4
        - 压缩，相对LZMA大一点点
        - 建议使用，用什么解压什么，只解压你所需要的，内存占用低
    - ETI
        - 在资源包中 不包含资源的类型信息
    - FR
        - 重新打包时需要重新构建包，和ClearFolders不同，它不会删除不再存在的包
    - ITTC
        - 增量构建检查时，忽略类型数的更改
    - Append Hash
        - 将文件哈希值附加到资源包名上
    - SM
        - 严格模式，如果打包时报错了，则打包直接失败无法成功
    - DRB
        - 运行时构建

3. Inspect
    
    主要是可视化的查看AB包中的详细信息
    ![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/718c5c022ef7751da3f26fe2ad42a034.image.webp)

## 3.打包后生成的文件
跳转到打包后的输出路径，查看文件夹下的内容

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

* model：这是AB包文件，也就是我们刚刚定义的AB包，包名字就叫model
* ios：这个和输出路径的同名文件，是AB包的主包，它是AssetBundle主清单文件，包含了所有被打包的 AssetBundle 名称，以及它们之间的依赖关系
* .manifest：每个AB包都会生成一个.manifest文件，用于描述对应的AB包的信息，主要记录，可以直接双击打开查看：
    ![image.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/9dc56bd6da7c86e99f9607d252f76e28.image.webp)
    主要包含以下几个部分：
    1. 版本校验
        * 包含 Hash 值和 CRC 校验码，用于比对更新和校验下载是否完整
        * ManifestFileVersion：说明 manifest 文件的版本号；
        * CRC：资源包的 校验码（循环冗余校验），运行时可用来检测资源是否损坏；
        * 哈希相关：
            * AssetFileHash：AB 文件整体的哈希，用于版本对比和一致性校验；
            * TypeTreeHash：类型树（TypeTree）的哈希，确保序列化结构一致，避免不同 Unity 版本序列化格式不兼容；
            * IncrementalBuildHash：增量构建时使用的哈希，判断是否需要重新打包
            * HashAppended：标志位，说明是否在 AB 包文件结尾附加了 Hash 信息（一般是 0 或 1）；
    2. 类型信息
        * ClassTypes：列出 AB 包里包含的 Unity 对象类型，以 Class ID 表示
        * 比如：Class: 1 → GameObject；Class: 4 → Transform；Class: 33 → MeshRenderer
        * SerializeReferenceClassIdentifiers：用于记录 SerializeReference 序列化的自定义类标识符（如果没有就为空数组）
    3. 资源内容
        * 显示该 AB 包中具体包含的资源路径
    4. 资源依赖
        * Dependencies数组中包含相关资源依赖

# AB包的使用
## 加载AB包
使用StreamingAssets该文件夹,我们在打包的时候已经勾选了复制到StreamingAssets文件夹当中了,使用这个文件夹的目的是:

1. 跨平台兼容,无论当前是在任何平台,UNITY都会根据不同的平台自动返回正确的路径
    > Windows: Application.dataPath + "/StreamingAssets"

    > macOS: Application.dataPath + "/Resources/Data/StreamingAssets"

    > Android: "jar:file://" + Application.dataPath + "!/assets"

    >iOS: Application.dataPath + "/Raw"
2. StreamingAssets 文件夹中的资源会被原样打包到最终游戏中,不会被 Unity 压缩或处理，保持 AssetBundle 完整性
3. 这个文件夹是是只读的,确保 AssetBundle 不会被意外修改,保证安全
4. 性能优势,直接从安装包中加载，速度快,不需要额外的文件复制操作
```csharp
string path = Application.streamingAssetsPath + "/" + "model";
AssetBundle ab = AssetBundle.LoadFromFile(path);
```
## 从AB包中加载资源
```csharp
//建议使用泛型+名字的方式,避免出现同名不同类型的情况
GameObject obj = ab.LoadAsset<GameObject>("Cube");
//也是指定类型的方式来加载AB包中的资源,不同于泛型的是这是通过反射的方式,因为在热更新中如果使用的是Lua脚本,就只能使用这种方式,因为Lua脚本不支持泛型
GameObject obj = ab.LoadAsset("Cube", typeof(GameObject)) as GameObject;
//在场景中实例化出加载的对象
Instantiate(obj, Vector3.zero, Quaternion.identity);
```
>AB包不能重复加载,不然会报错

## 异步加载AB包

```csharp
//>异步加载AB包资源-协程
IEnumerator LoadABResAsync(string abName, string resName)
{
    //1.异步加载AB包
    AssetBundleCreateRequest abcr = AssetBundle.LoadFromFileAsync(Application.streamingAssetsPath + "/" + abName);
    yield return abcr;
    //2.从AB包中异步加载资源
    AssetBundleRequest abr = abcr.assetBundle.LoadAssetAsync(resName, typeof(GameObject));
    yield return abr;
    //3.获取异步加载的资源
    GameObject obj = abr.asset as GameObject;
    yield return obj;
}
```

## 卸载AB包
```csharp
//>卸载AB包中的资源,true同时卸载场景中已经从该AB包中加载过的实例,false只卸载AB包自己
ab.Unload(false);
AssetBundle.UnloadAllAssetBundles(false);//卸载当前所有
```

# AB包的依赖
>**加载一个AB包之前先要判断它是否有相关的依赖,先加载依赖包,然后再加载当前AB包**
1. 利用主包来获取依赖信息

```csharp
AssetBundle abMain = AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/" + "iOS");
```
2. 加载主包中的mainfest文件

```csharp
AssetBundleManifest abMainfest = abMain.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
```
3. 从主包中的mainfest文件中获取该AB包的Dependencies,它是一个数组,里面包含了所有依赖包的名字

```csharp
string[] dependencies = abMainfest.GetAllDependencies("model");
```
4. 加载所有的依赖包

```csharp
//临时存储依赖包,方便后续能够及时卸载,实际项目中我们应该用一个容器存储已经加载的AB包
List<AssetBundle> dependencyABs = new List<AssetBundle>(dependencies.Length);
for (int i = 0; i < dependencies.Length; i++)
{
    AssetBundleCreateRequest dependencyRequest = AssetBundle.LoadFromFileAsync(Application.streamingAssetsPath + "/" + dependencies[i]);
    yield return dependencyRequest; // 等待异步加载完成
    dependencyABs.Add(dependencyRequest.assetBundle);
}
```

# 引用计数
添加引用计数目的是方便知晓某个AB包的引用次数，使用资源时引用计数+1，释放资源时引用计数-1，便于及时卸载，Addressables中包含了这个功能，我们使用AB包也可以在代码中自己添加这个逻辑

# 归纳总结——AssetBundelManager
该管理器已包含了上述所描述的知识点
```csharp
using System.Collections;
using System.Collections.Generic;
using OpenCover.Framework.Model;
using UnityEngine;
using UnityEngine.Events;

public class ABMgr : SingletonAutoMono<ABMgr>
{
    //主包
    private AssetBundle mainAB = null;
    //主包依赖获取配置文件
    private AssetBundleManifest manifest = null;

    //选择存储 AB包的容器
    //AB包不能够重复加载 否则会报错
    //使用引用计数管理AB包对象
    private Dictionary<string, ABInfo> abDic = new Dictionary<string, ABInfo>();

    private class ABInfo
    {
        public AssetBundle assetBundle;
        //引用计数
        public int linkCount;
    }

    /// <summary>
    /// 获取AB包加载路径
    /// </summary>
    private string PathUrl
    {
        get
        {
            return Application.streamingAssetsPath + "/";
        }
    }

    /// <summary>
    /// 主包名 根据平台不同 报名不同
    /// </summary>
    private string MainName
    {
        get
        {
#if UNITY_IOS
            return "IOS";
#elif UNITY_ANDROID
            return "Android";
#else
            return "PC";
#endif
        }
    }

    /// <summary>
    /// 加载主包 和 配置文件
    /// 因为加载所有包是 都得判断 通过它才能得到依赖信息
    /// 所以写一个方法
    /// </summary>
    private void LoadMainAB()
    {
        if (mainAB == null)
        {
            mainAB = AssetBundle.LoadFromFile(PathUrl + MainName);
            manifest = mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        }
    }

    /// <summary>
    /// 加载指定包的依赖包
    /// </summary>
    /// <param name="abName"></param>
    private void LoadDependencies(string abName)
    {
        //加载主包
        LoadMainAB();
        //获取依赖包
        string[] strs = manifest.GetAllDependencies(abName);
        for (int i = 0; i < strs.Length; i++)
        {
            if (!abDic.ContainsKey(strs[i]))
            {
                AssetBundle ab = AssetBundle.LoadFromFile(PathUrl + strs[i]);
                abDic.Add(strs[i], new ABInfo { assetBundle = ab, linkCount = 1 });
            }
            else
            {
                abDic[strs[i]].linkCount++;
            }
        }
    }

    /// <summary>
    /// 泛型资源同步加载
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <returns></returns>
    public T LoadRes<T>(string abName, string resName) where T : Object
    {
        //加载依赖包
        LoadDependencies(abName);
        //加载目标包
        if (!abDic.ContainsKey(abName))
        {
            AssetBundle ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDic.Add(abName, new ABInfo { assetBundle = ab, linkCount = 1 });
        }
        else
        {
            abDic[abName].linkCount++;
        }

        //得到加载出来的资源
        T obj = abDic[abName].assetBundle.LoadAsset<T>(resName);
        //如果是GameObject 因为GameObject 100%都是需要实例化的
        //所以我们直接实例化
        if (obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }

    /// <summary>
    /// Type同步加载指定资源
    /// </summary>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <param name="type"></param>
    /// <returns></returns>
    public Object LoadRes(string abName, string resName, System.Type type)
    {
        //加载依赖包
        LoadDependencies(abName);
        //加载目标包
        if (!abDic.ContainsKey(abName))
        {
            AssetBundle ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDic.Add(abName, new ABInfo { assetBundle = ab, linkCount = 1 });
        }
        else
        {
            abDic[abName].linkCount++;
        }

        //得到加载出来的资源
        Object obj = abDic[abName].assetBundle.LoadAsset(resName, type);
        //如果是GameObject 因为GameObject 100%都是需要实例化的
        //所以我们直接实例化
        if (obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }

    /// <summary>
    /// 名字 同步加载指定资源
    /// </summary>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <returns></returns>
    public Object LoadRes(string abName, string resName)
    {
        //加载依赖包
        LoadDependencies(abName);
        //加载目标包
        if (!abDic.ContainsKey(abName))
        {
            AssetBundle ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDic.Add(abName, new ABInfo { assetBundle = ab, linkCount = 1 });
        }
        else
        {
            abDic[abName].linkCount++;
        }

        //得到加载出来的资源
        Object obj = abDic[abName].assetBundle.LoadAsset(resName);
        //如果是GameObject 因为GameObject 100%都是需要实例化的
        //所以我们直接实例化
        if (obj is GameObject)
            return Instantiate(obj);
        else
            return obj;
    }

    /// <summary>
    /// 泛型异步加载资源
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <param name="callBack"></param>
    public void LoadResAsync<T>(string abName, string resName, UnityAction<T> callBack) where T : Object
    {
        StartCoroutine(ReallyLoadResAsync<T>(abName, resName, callBack));
    }

    //协程异步加载
    private IEnumerator ReallyLoadResAsync<T>(string abName, string resName, UnityAction<T> callBack) where T : Object
    {
        //加载依赖包
        LoadDependencies(abName);
        //加载目标包
        if (!abDic.ContainsKey(abName))
        {
            AssetBundle ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDic.Add(abName, new ABInfo { assetBundle = ab, linkCount = 1 });
        }
        else
        {
            abDic[abName].linkCount++;
        }
        //异步加载包中资源
        AssetBundleRequest abq = abDic[abName].assetBundle.LoadAssetAsync<T>(resName);
        yield return abq;

        if (abq.asset is GameObject)
            callBack(Instantiate(abq.asset) as T);
        else
            callBack(abq.asset as T);
    }

    /// <summary>
    /// Type异步加载资源
    /// </summary>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <param name="type"></param>
    /// <param name="callBack"></param>
    public void LoadResAsync(string abName, string resName, System.Type type, UnityAction<Object> callBack)
    {
        StartCoroutine(ReallyLoadResAsync(abName, resName, type, callBack));
    }

    private IEnumerator ReallyLoadResAsync(string abName, string resName, System.Type type, UnityAction<Object> callBack)
    {
        //加载依赖包
        LoadDependencies(abName);
        //加载目标包
        if (!abDic.ContainsKey(abName))
        {
            AssetBundle ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDic.Add(abName, new ABInfo { assetBundle = ab, linkCount = 1 });
        }
        else
        {
            abDic[abName].linkCount++;
        }
        //异步加载包中资源
        AssetBundleRequest abq = abDic[abName].assetBundle.LoadAssetAsync(resName, type);
        yield return abq;

        if (abq.asset is GameObject)
            callBack(Instantiate(abq.asset));
        else
            callBack(abq.asset);
    }

    /// <summary>
    /// 名字 异步加载 指定资源
    /// </summary>
    /// <param name="abName"></param>
    /// <param name="resName"></param>
    /// <param name="callBack"></param>
    public void LoadResAsync(string abName, string resName, UnityAction<Object> callBack)
    {
        StartCoroutine(ReallyLoadResAsync(abName, resName, callBack));
    }

    private IEnumerator ReallyLoadResAsync(string abName, string resName, UnityAction<Object> callBack)
    {
        //加载依赖包
        LoadDependencies(abName);
        //加载目标包
        if (!abDic.ContainsKey(abName))
        {
            AssetBundle ab = AssetBundle.LoadFromFile(PathUrl + abName);
            abDic.Add(abName, new ABInfo { assetBundle = ab, linkCount = 1 });
        }
        else
        {
            abDic[abName].linkCount++;
        }
        //异步加载包中资源
        AssetBundleRequest abq = abDic[abName].assetBundle.LoadAssetAsync(resName);
        yield return abq;

        if (abq.asset is GameObject)
            callBack(Instantiate(abq.asset));
        else
            callBack(abq.asset);
    }

    //卸载AB包的方法 (引用计数管理)
    public void UnLoadAB(string name)
    {
        if (abDic.ContainsKey(name))
        {
            abDic[name].linkCount--;
            if (abDic[name].linkCount <= 0)
            {
                abDic[name].assetBundle.Unload(false);
                abDic.Remove(name);
            }
        }
    }

    //强制卸载指定AB包 (忽略引用计数)
    public void ForceUnLoadAB(string name)
    {
        if (abDic.ContainsKey(name))
        {
            abDic[name].assetBundle.Unload(false);
            abDic.Remove(name);
        }
    }

    //获取AB包的引用计数
    public int GetABReferenceCount(string name)
    {
        if (abDic.ContainsKey(name))
        {
            return abDic[name].linkCount;
        }
        return 0;
    }

    //清空AB包的方法
    public void ClearAB()
    {
        AssetBundle.UnloadAllAssetBundles(false);
        abDic.Clear();
        //卸载主包
        mainAB = null;
        manifest = null;
    }
}
```



AssetBundle详解

# 一、C# 调用 Lua

## 本质
- **传参数 → 调用 Lua 函数 → 取结果**。

## 过程
1. **拿到 Lua 函数**
   - 通过 `[CSharpCallLua]` 标记 delegate 类型。
   - Lua function 可以赋值给 C# 的 delegate，xLua 会生成 **DelegateBridge** 保存 Lua function 的引用。

2. **调用链**
   - C# 调用 delegate → 跳转到 **DelegateBridge** → 执行 `__Gen_Delegate_Imp*` 模板方法。
   - 模板方法负责：
     - 参数压栈
     - 执行 Lua 函数
     - 从栈取返回值并转换成 C# 类型

3. **关键组件**
   - **DelegateBridge**：桥接委托和 Lua function。
   - **ObjectTranslator**：完成参数和返回值的类型适配。

---

# 二、Lua 调用 C#

## 本质
- **传参数 → 调用 C# 方法 → 返回值压回栈**。

## 过程
1. **注册 C# 方法**
   - 通过 `[LuaCallCSharp]` 标记类型，xLua 将方法暴露给 Lua VM。
   - Lua 脚本中可直接调用：`CS.Type.Method()`。

2. **调用链**
   - Lua 调用 `CS.UnityEngine.Debug.Log("Hello")`
   - Lua VM 找到注册的 C# 方法入口
   - **ObjectTranslator** 把 `"Hello"` 转成 C# string
   - 执行 `Debug.Log()`
   - 如果方法有返回值，压回 Lua 栈

3. **关键组件**
   - **ObjectTranslator**：参数/返回值转换
   - **LuaCallCSharp**：方法注册到 Lua

---

# 三、交互机制对比

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

| 场景 | 本质流程 | 桥接/适配组件 |
|------|----------|---------------|
| **C# 调 Lua** | 参数压栈 → 调 Lua 函数 → 返回值取出 | DelegateBridge + ObjectTranslator |
| **Lua 调 C#** | Lua 参数出栈 → 调 C# 方法 → 返回值压回 | ObjectTranslator + LuaCallCSharp |

---

# 四、面试回答思路

- **简答版**  
> Lua 和 C# 的交互，本质上就是通过 Lua 栈传递参数和结果。  
> - C# 调 Lua：传参数过去，拿结果回来；  
> - Lua 调 C#：把参数传给 C# 方法，结果再压回 Lua 栈。  

- **深入版**  
> C# 调 Lua 时，会通过 DelegateBridge 作为桥接类，把 C# delegate 映射到 Lua function，参数和返回值交给 ObjectTranslator 做类型转换。  
> Lua 调 C# 时，依赖 LuaCallCSharp 注册机制，Lua VM 调用时 ObjectTranslator 会把 Lua 栈参数转成 C# 类型，方法执行完结果再压回 Lua 栈。  
> 所以本质就是 **栈传递 + 类型翻译 + 桥接调用**。

---