Unity AssetBundle 之（进阶）简单的实现 AssetBundle 框架，加载AB包资源，自动加载依赖资源（无需手动加载），自动打AB标签，自动打包AssetBundle的框架方法

曾经终败给现在 2022-11-28 10:58 519阅读 0赞

![2020081716132052.png][]

# Unity AssetBundle 之 （进阶）简单的实现 AssetBundle  框架，加载AB包资源，自动加载依赖资源（无需手动加载），自动打AB标签，自动打包AssetBundle的框架方法 #

**目录**

Unity AssetBundle 之 （进阶）简单的实现 AssetBundle  框架，加载AB包资源，自动加载依赖资源（无需手动加载），自动打AB标签，自动打包AssetBundle的框架方法

一、简单介绍

框架使用流程：

二、框架实现原理图

三、脚本说明

编辑器脚本

辅助类

关键脚本

四、AssetBundle 资源使用过程中的内存状态图

五、效果预览

六、实现步骤

七，关键脚本

八、参考工程

--------------------

## 一、简单介绍 ##

Unity中的一些基础知识点。

本节介绍，Asset Bundle 在 Unity中的使用，进阶第六篇，框架的实现，该框架可自动打AB标签，自动打包AssetBundle，加载资源的时候，自动加载依赖项资源，无需手动加载的框架方法，有不对的地方欢迎指正。

### 框架使用流程： ###

1、编辑器 AutoSetAssetBundleLabel 使用这个类自动标记AB包标签

2、编辑器 BuildAssetBundle 自动打包标记的AB包资源为 AssetBundle

3、StartCoroutine(AssetBundleManager.GetInstance().LoadAssetBundlePack(\_SceneName, \_AssetBundleName, LoadAllABComplete)); 启动开始 WWW 下载指定的AssetBundle包，等待相关的所有依赖包下载完成

4、AssetBundle 下载完成，即可 AssetBundleManager.GetInstance().LoadAsset(\_SceneName, \_AssetBundleName, \_AssetName, false); 加载对应包中的资源了，最后一个参数为是否缓存资源的标志

## 二、框架实现原理图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70][]

## 三、脚本说明 ##

### 编辑器脚本 ###

1、AutoSetAssetBundleLabel  自动设置AB标签

（1）自动标记指定目录下的资源，标记规则是： 场景文件夹名/功能文件夹名.ab 或者 场景文件夹名/功能文件夹名.u3d

（2）会自动递归文件夹中的每一个资源

（3）会排除 .meta 文件

（4）场景资源标记的扩展名为 u3d，其他资源扩展名为 ab

2、AutoRemoveAssetBundleLabel  自动移除AB标签

（1）自动移出指定文件夹下所有被AB标记的资源 AssetBundle 标签

（2）会自动递归文件夹中的每一个资源，保证标记都被移除

3、BuildAssetBundle  打成 AssetBundle 包

（1）根据设置的打包路径和平台，打包AssetBundle 资源包到指定路径文件夹下

4、DeleteAssetBundle 删除指定路径的 AssetBundle 包

（1）根据设置的AssetBundle包路径，删除 AssetBundle 资源包

### 辅助类 ###

1、PathTools 管理路径常量和相关路径静态方法

（1）得到 AB 资源的输入目录

（2）获得 AB 包输出路径

（3）获得平台路径、获得平台名称

（4）返回 WWW 下载 AB 包加载路径

2、ABDefine 管理 AssetBunlde 框架定义的一些常量和委托等

（1）委托定义 DelLoadComplete

（2）常量定义 ASSETBUNDLE\_MANIFEST

3、ABManifestLoader 清单文件下载

（1）下载 Manifest 清单文件

（2）获取 AssetBundleManifest 系统实例

（3）获取 AsssetBundleManifest(系统类)指定包名称的所有依赖项

（4）释放清单文件资源

4、ABRelation AB关系类

（1）增加依赖关系

（2）移除依赖关系

（3）获得该包的所有依赖关系

（4）增加引用（被依赖）关系

（5）移除引用关系

（6）获得该包的所有引用关系

### 关键脚本 ###

1、AssetLoader AssetBundle 包资源加载类

（1）加载Assetbundle中的指定的资源，可以设置是否缓存该资源

（2）卸载Assetbundle中的指定的资源

（3）卸载内存镜像资源、释放当前 AssetBundle 内存镜像资源，且释放内存资源

（4）查询Assetbundle包中所有资源名称

2、SingleABLoader 单AssetBundle包加载类

（1）下载指定 AssetBundle 资源

（2）加载指定AB内的资源，可以设置是否缓存该资源

（3）卸载指定AB内的资源

（4）卸载当前 AssetBundle 资源包，且卸载所有资源

（5）查询 AssetBundle 包中所有的资源名称

3、MultiABManager 多个 AB 包管理

（1）下载指定 AB 包，同时会递归下载该 AB 包相关的所有依赖包

（2）加载指定AB内的资源，可以设置是否缓存该资源

（3）释放包中所有加载的资源  (建议场景中切换的时候调用，避免卡顿)

4、AssetBundleManager 资源包管理类，对外的接口类

（1）下载指定 AB 包，同时会递归下载该 AB 包相关的所有依赖包

（2）指定 AB 包所有包下载完毕（包括所有依赖包），即可加载包中指定资源

（3）释放该 AB包所有资源（包括依赖包）

## 四、AssetBundle 资源使用过程中的内存状态图 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1][]

## 五、效果预览 ##

![20200817222545739.gif][]

## 六、实现步骤 ##

1、打开Unity ，新建一个空工程

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2][]

2、把资源导进来，这里 AssetBundle 标记标签的文件夹为 AB\_Resources，文件结构如下，需要标记的资源如图功能文件夹放置

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3][]

3、新建脚本相关脚本，实现相关类，功能说明如上

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4][]

4、AssetBundleTools 工具栏

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5][]

5、AssetBundleTools  点击 Set AB Label 设置标签， BuildAllAssetBundles，打包AB 包

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6][]

6、场景中添加 TestAssetBundleManager 测试脚本

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7][]

7、运行场景，效果如上

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8][]

## 七，关键脚本 ##

1、AssetLoader

/****************************************************
    文件：AssetLoader.cs
    作者：Administrator
    邮箱：https://blog.csdn.net/u014361280 
    日期：2020/08/15 09:48:26
    功能：AB (AssetBundle)资源加载
        功能：
            1、管理与加载指定AB的资源
            2、加载具有“缓存功能”的资源，带选用参数
            3、卸载、释放资源
            4、查看当前AB资源
    *****************************************************/
    
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    namespace ABFw
    {
        public class AssetLoader : System.IDisposable
        {
            // 当前AssetBundle 
            private AssetBundle _CurrentAssetBundle;
    
            // 缓存集合
            private Hashtable _Ht;
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="abObj">给定www加载的AssetBundle实例</param>
            public AssetLoader(AssetBundle abObj) {
                if (abObj != null)
                {
                    _CurrentAssetBundle = abObj;
                    _Ht = new Hashtable();
    
                }
                else {
                    Debug.Log(GetType()+ " /构造函数 AssetLoader() 参数为空，请检查");
                }
            }
    
            /// <summary>
            /// 加载资源
            /// </summary>
            /// <param name="assetName">资源名称</param>
            /// <param name="isCache">是否缓存</param>
            /// <returns></returns>
            public UnityEngine.Object LoadAsset(string assetName, bool isCache=false) {
    
                return LoadResource<UnityEngine.Object>(assetName,isCache);
            }
    
            /// <summary>
            /// 卸载指定资源
            /// </summary>
            /// <param name="asset">资源</param>
            /// <returns></returns>
            public bool UnLoadAsset(UnityEngine.Object asset) {
    
                if (asset !=null)
                {
                    Resources.UnloadAsset(asset);
                    return true;
                }
    
                Debug.LogError(GetType()+ "/UnLoadAsset()/参数 asset is null,请检查");
    
                return false;
            }
    
            /// <summary>
            /// 卸载内存镜像资源
            /// </summary>
            public void Dispose()
            {
                _CurrentAssetBundle.Unload(false);
            }
    
            /// <summary>
            /// 释放当前 AssetBundle 内存镜像资源，且释放内存资源
            /// </summary>
            public void DisposeAll() {
                _CurrentAssetBundle.Unload(true);
            }
    
            /// <summary>
            /// 查询AB包中所有资源名称
            /// </summary>
            /// <returns></returns>
            public string[] RetriveAllAssetName() {
                return _CurrentAssetBundle.GetAllAssetNames();
            }
    
    
            /// <summary>
            /// 加载资源
            /// </summary>
            /// <typeparam name="T">泛型</typeparam>
            /// <param name="assetName">资源名称</param>
            /// <param name="isCache">是否缓存</param>
            /// <returns></returns>
            private T LoadResource<T>(string assetName, bool isCache) where T : UnityEngine.Object {
    
                // 是否缓存集合中已存在
                if (_Ht.Contains(assetName))
                {
                    return _Ht[assetName] as T;
                }
    
                // 没有，则加载
                T tmpTResource = _CurrentAssetBundle.LoadAsset<T>(assetName);
    
                // 根据要求是否保存到缓存中
                if (tmpTResource != null && isCache == true)
                {
                    _Ht.Add(assetName, tmpTResource);
                }
                else if (tmpTResource == null) {
                    Debug.LogError(GetType() + "/LoadResource<T>()/ 加载资源为空，请检查 参数 assetName = "+ assetName);
                }
    
                return tmpTResource;
            }
        }
    }

2、SingleABLoader

/****************************************************
    文件：SingleABLoader.cs
    作者：Administrator
    邮箱：https://blog.csdn.net/u014361280 
    日期：2020/08/15 10:34:52
    功能：下载 AssetBundle 包
        使用 WWW 下载
    *****************************************************/
    
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    namespace ABFw
    {
        public class SingleABLoader : System.IDisposable
        {
    
            // 引用类：资源加载类
            private AssetLoader _AssetLoader;
    
            // 委托
            private DelLoadComplete _LoadCompleteHandler;
    
            // AssetBundle 名称
            private string _ABName;
    
            // AssetBundle 下载路径
            private string _ABDownLoadPath;
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="ABName">AB包名</param>
            /// <param name="loadComplete">委托</param>
            public SingleABLoader(string ABName, DelLoadComplete loadComplete)
            {
                _AssetLoader = null;
                _ABName = ABName;
    
                // 委托定义
                _LoadCompleteHandler = loadComplete;
    
                //AB包下载路径
                _ABDownLoadPath = PathTools.GetWWWAssetBundlePath() + "/" + _ABName;
            }
    
            /// <summary>
            /// 加载 AssetBundle 资源
            /// </summary>
            /// <returns></returns>
            public IEnumerator LoadAssetBundle() {
                using (WWW www = new WWW(_ABDownLoadPath))
                {
                    yield return www;
                    // www 下载完成
                    if (www.progress >= 1)
                    {
                        // 获取 AssetBundle 的实例
                        AssetBundle abObj = www.assetBundle;
                        if (abObj != null)
                        {
                            // 实例化引用类
                            _AssetLoader = new AssetLoader(abObj);
    
                            // AssetBundle 下载完毕，调用委托
                            if (_LoadCompleteHandler !=null)
                            {
                                _LoadCompleteHandler(_ABName);
                            }
                        }
                        else {
                            Debug.LogError(GetType()+ "/ LoadAssetBundle()/WWW 下载出错，请检查，AssetBundle Path = "+_ABDownLoadPath +"; 错误信息："+www.error);
                        }
                    }
                }//using_End
            }
    
            /// <summary>
            /// 加载指定AB内的资源
            /// </summary>
            /// <param name="assetName"></param>
            /// <param name="isCache"></param>
            /// <returns></returns>
            public UnityEngine.Object LoadAsset(string assetName, bool isCache) {
    
                if (_AssetLoader != null)
                {
                    return _AssetLoader.LoadAsset(assetName,isCache);
                }
    
                Debug.LogError(GetType()+ "/LoadAsset()/参数_AssetLoader is null,请检查");
    
                return null;
            }
    
            /// <summary>
            /// 卸载指定资源
            /// </summary>
            /// <param name="asset"></param>
            public void UnLoadAsset(UnityEngine.Object asset) {
                if (_AssetLoader != null)
                {
                    _AssetLoader.UnLoadAsset(asset);
                }
                else {
                    Debug.LogError(GetType() + "/LoadAsset()/参数_AssetLoader is null,请检查");
    
                }
            }
    
            /// <summary>
            /// 释放资源
            /// </summary>
            public void Dispose()
            {
                if (_AssetLoader != null)
                {
                    _AssetLoader.Dispose();
                    _AssetLoader = null;
                }
                else
                {
                    Debug.LogError(GetType() + "/LoadAsset()/参数_AssetLoader is null,请检查");
    
                }
            }
    
            /// <summary>
            /// 卸载当前 AssetBundle 资源包，且卸载所有资源
            /// </summary>
            public void DisposeAll()
            {
                if (_AssetLoader != null)
                {
                    _AssetLoader.DisposeAll();
                    _AssetLoader = null;
                }
                else
                {
                    Debug.LogError(GetType() + "/LoadAsset()/参数_AssetLoader is null,请检查");
    
                }
            }
    
            /// <summary>
            /// 查询 AssetBundle 包中所有的资源名称
            /// </summary>
            /// <returns></returns>
            public string[] RetriveAllAssetName() {
                if (_AssetLoader != null)
                {
                    return _AssetLoader.RetriveAllAssetName();
                    
                }
                
                Debug.LogError(GetType() + "/LoadAsset()/参数_AssetLoader is null,请检查");
    
                return null;
                
            }
        }
    }

3、MultiABManager

/****************************************************
    文件：MultiABManager.cs
    作者：Administrator
    邮箱：https://blog.csdn.net/u014361280 
    日期：2020/08/15 15:46:41
    功能：一个场景中多个AssetBundle 管理
        1、获取AB包的依赖和引用关系
        2、管理AssetBundle包之间的自动连锁（递归）加载机制
    *****************************************************/
    
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    namespace ABFw
    {
        public class MultiABManager 
        {
            // 引用类：“单个AB包加载的实现”
            private SingleABLoader _CurrentSingleABLoader;
    
            // AB 包实现类  缓存集合（作用：缓存AB包，放置重复加载，即“AB包缓存集合”）
            private Dictionary<string, SingleABLoader> _DicSingleABLoaderCache;
    
            // 当前场景（调试使用）名称
            private string _CurrentSceneName;
    
            // 当前 AssetBundle 名称
            private string _CurrentABName;
    
            // AB 包与对应依赖关系集合
            private Dictionary<string, ABRelation> _DicABRelation;
    
            // 委托 所有AB包加载完成
            private DelLoadComplete _LoadAllABPackageCompleteHandler;
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="CurrentSceneName">场景名称</param>
            /// <param name="CurrentABName">Asset Bundle 名称</param>
            /// <param name="LoadAllABPackageCompleteHandler">委托</param>
            public MultiABManager(string CurrentSceneName, string CurrentABName, DelLoadComplete LoadAllABPackageCompleteHandler)
            {
                _CurrentSceneName = CurrentSceneName;
                _CurrentABName = CurrentABName;
                _DicSingleABLoaderCache = new Dictionary<string, SingleABLoader>();
                _DicABRelation = new Dictionary<string, ABRelation>();
    
                _LoadAllABPackageCompleteHandler = LoadAllABPackageCompleteHandler;
            }
    
            /// <summary>
            /// 完成指定AB包调用
            /// </summary>
            /// <param name="abName">AB包名称</param>
            private void CompleteLoadAB(string abName) {
    
                Debug.Log(GetType()+ "/CompleteLoadAB()/ 当前完成 AssetBundle 加载的包的包名为 ：" + abName);
    
                if (abName.Equals(_CurrentABName))
                {
                    if (_LoadAllABPackageCompleteHandler != null)
                    {
                        _LoadAllABPackageCompleteHandler(abName);
                    }
                }
            }
    
    
            /// <summary>
            /// 加载 AB 包（包括依赖项）
            /// </summary>
            /// <param name="abName"></param>
            /// <returns></returns>
            public IEnumerator LoadAssetBundle(string abName) {
    
                // AB 包关系的建立
                if (_DicABRelation.ContainsKey(abName)==false)
                {
                    ABRelation abRelationObj = new ABRelation(abName);
                    _DicABRelation.Add(abName,abRelationObj);
                }
    
                ABRelation tmpABRelationObj = _DicABRelation[abName];
    
                // 得到指定AB所有的依赖关系（查询Manifest清单文件）
                string[] strDependencyArray = ABManifestLoader.GetInstance().RetrivalDependency(abName);
                foreach (string item_Dependency in strDependencyArray)
                {
                    // 添加“依赖项”
                    tmpABRelationObj.AddDependency(item_Dependency);
                    // 添加引用(背以来) （方便递归调用）
                    yield return LoadReference(item_Dependency,abName);
                }
    
                // 真正加载 AB 包
                if (_DicSingleABLoaderCache.ContainsKey(abName) == true)
                {
                    yield return _DicSingleABLoaderCache[abName].LoadAssetBundle();
                }
                else {
                    _CurrentSingleABLoader = new SingleABLoader(abName, CompleteLoadAB);
                    _DicSingleABLoaderCache.Add(abName,_CurrentSingleABLoader);
                    yield return _CurrentSingleABLoader.LoadAssetBundle();
                }
    
             
            }
    
    
            /// <summary>
            /// 加载应用 AB 包
            /// </summary>
            /// <param name="abName">AB 包名称</param>
            /// <param name="refABName">被引用AB包名称</param>
            /// <returns></returns>
            private IEnumerator LoadReference(string abName, string refABName) {
    
                // AB 包已经加载了
                if (_DicABRelation.ContainsKey(abName))
                {
                    ABRelation tmpABRelationObj = _DicABRelation[abName];
    
                    // 添加AB包引用关系（被依赖关系）
                    tmpABRelationObj.AddReference(refABName);
                }
                else {
    
                    ABRelation tmpABRelationObj = new ABRelation(abName);
                    tmpABRelationObj.AddReference(refABName);
                    _DicABRelation.Add(abName,tmpABRelationObj);
    
    
                    // 开始加载依赖的包（一个递归调用）
                    yield return LoadAssetBundle(abName);
                }
    
    
               
            }
    
            /// <summary>
            /// 加载AB包资源
            /// </summary>
            /// <param name="abName">Asset Bundle 资源包名</param>
            /// <param name="assetName">包中具体资源名称</param>
            /// <param name="isCache">是否缓存</param>
            /// <returns></returns>
            public UnityEngine.Object LoadAsset(string abName, string assetName, bool isCache) {
    
                foreach (string item_abName in _DicSingleABLoaderCache.Keys)
                {
                    if (abName == item_abName)
                    {
                        return _DicSingleABLoaderCache[item_abName].LoadAsset(assetName, isCache);
                    }
    
                }
                Debug.LogError(GetType() + "/LoadAsset()/找不到AssetBundle包，无法加载资源，请检查！abName = " + abName + ", assetName = " + assetName);
    
                return null;
            }
    
            /// <summary>
            /// 释放包中所有加载的资源  (建议场景中切换的时候调用，避免卡顿)
            /// </summary>
            public void DisposeAllAsset() {
    
                try
                {
                    // 逐一释放所有加载过的AssetBundle包中的资源
                    foreach (SingleABLoader item_SABLoader in _DicSingleABLoaderCache.Values)
                    {
                        item_SABLoader.DisposeAll();
                    }
                }
                finally {
                    _DicSingleABLoaderCache.Clear();
                    _DicSingleABLoaderCache = null;
    
                    // 释放其他对象占用的资源
                    _DicABRelation.Clear();
                    _DicABRelation = null;
                    _CurrentABName = null;
                    _CurrentSceneName = null;
                    _LoadAllABPackageCompleteHandler = null;
    
                    // 卸载没有使用到的资源
                    Resources.UnloadUnusedAssets();
                    // 强制垃圾收集
                    System.GC.Collect();
                }
                
    
                
            }
    
        }//class_End
    }

4、AssetBundleManager

/****************************************************
    文件：AssetBundleManager.cs
    作者：Administrator
    邮箱：https://blog.csdn.net/u014361280 
    日期：2020/08/15 16:57:10
    功能：所有场景的 Asset Bundle 管理
        1、提取 Manifest 清单文件，缓存本脚本
        2、以场景为单位，管理正给项目中所有的 AssetBundle 包
    *****************************************************/
    
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    namespace ABFw
    {
        public class AssetBundleManager : MonoBehaviour
        {
            // 本类实例
            private static AssetBundleManager _Instance;
    
            // 场景集合
            private Dictionary<string, MultiABManager> _DicAllScenes = new Dictionary<string, MultiABManager>();
    
            // AssetBundle (清单文件)系统类
            private AssetBundleManifest _ManifestObj = null;
    
            private AssetBundleManager() { }
    
            /// <summary>
            /// 得到实例
            /// </summary>
            /// <returns></returns>
            public static AssetBundleManager GetInstance() {
                if (_Instance == null)
                {
                    _Instance = new GameObject("_AssetBundleManager").AddComponent<AssetBundleManager>();
                }
    
                return _Instance;
            }
    
            private void Awake()
            {
                // 加载 Manifest 清单文件
                StartCoroutine(ABManifestLoader.GetInstance().LoadManifest());
            }
    
            /// <summary>
            /// 下载 指定 AssetBundle 包
            /// </summary>
            /// <param name="sceneName"></param>
            /// <param name="abName"></param>
            /// <param name="loadAllComplete"></param>
            /// <returns></returns>
            public IEnumerator LoadAssetBundlePack(string sceneName, string abName, DelLoadComplete loadAllComplete) {
    
                // 参数检查
                if (string.IsNullOrEmpty(sceneName) == true || string.IsNullOrEmpty(abName) == true)
                {
                    Debug.LogError(GetType() + "/LoadAssetBundlePack()/sceneName or   is null，请检查");
    
                    yield return null;
                }
    
                // 等待 Manifest 清单文件加载完成
                while (ABManifestLoader.GetInstance().IsLoadFinished == false) {
                    yield return null;
                }
    
                _ManifestObj = ABManifestLoader.GetInstance().GetABManifest();
                if (_ManifestObj == null)
                {
                    Debug.LogError(GetType()+ "/LoadAssetBundlePack()/_ManifestObj is null,请先确保加载 Manifest 清单文件");
                    yield return null;
                }
    
                if (_DicAllScenes.ContainsKey(sceneName) == false)
                {
                    MultiABManager multiABManagerObj = new MultiABManager(sceneName,abName,loadAllComplete);
                    _DicAllScenes.Add(sceneName, multiABManagerObj);
    
                }
    
                // 多包管理类
                MultiABManager tmpMultiABMgrObj = _DicAllScenes[sceneName];
                if (tmpMultiABMgrObj ==null)
                {
                    Debug.LogError(GetType() + "/LoadAssetBundlePack()/tmpMultiABMgrObj is null,请检查");
                }
    
    
                yield return tmpMultiABMgrObj.LoadAssetBundle(abName);
    
                
            }
    
            /// <summary>
            /// 加载包中指定资源
            /// </summary>
            /// <param name="sceneName">场景名称</param>
            /// <param name="abName">AsssetBundle 名称</param>
            /// <param name="assetName">资源名称</param>
            /// <param name="isCache">是否缓存</param>
            /// <returns></returns>
            public UnityEngine.Object LoadAsset(string sceneName,string abName, string assetName,bool isCache) {
    
                if (_DicAllScenes.ContainsKey(sceneName) == true)
                {
                    MultiABManager multiABManager = _DicAllScenes[sceneName];
                    return multiABManager.LoadAsset(abName, assetName,isCache);
                }
    
                Debug.LogError(GetType()+ "/LoadAsset()/找不到场景名称，无法加载AssetBundle资源，请检查！sceneName = " + sceneName);
    
    
                return null;
            }
    
            /// <summary>
            /// 释放资源
            /// </summary>
            /// <param name="sceneName"></param>
            public void DisposeAllAsset(string sceneName) {
                if (_DicAllScenes.ContainsKey(sceneName) == true)
                {
                    MultiABManager multiABManager = _DicAllScenes[sceneName];
                    multiABManager.DisposeAllAsset();
                }
                else {
                    Debug.LogError(GetType() + "/DisposeAllAsset()/找不到场景名称，无法释放 AssetBundle 资源，请检查！sceneName = " + sceneName);
    
                }
            }
    
        }//class_End
    }

## 八、参考工程 ##

下载地址：[Unity AssetBundle 之 （进阶）简单的实现 AssetBundle 框架][Unity AssetBundle _ _ AssetBundle]

**最后，郑重鸣谢刘老师**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9][]

[2020081716132052.png]: /images/20221124/bb03f8fad47040f8afe94328cfa18ce8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70]: /images/20221124/3ec3e2697b7849b2aa42a5bfd12c50bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1]: /images/20221124/be0956dba0f64a73807380deaf925e72.png
[20200817222545739.gif]: /images/20221124/fc505576fc044d4aaaaf42a11f85b160.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2]: /images/20221124/c46c0d4bc87c4514b16957fe7c887036.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3]: /images/20221124/b5a426035fa8425bbe345d2ac68a23bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4]: /images/20221124/5f899698512f47e688c567f224d5e5aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5]: /images/20221124/4a4b802cafc3461d9935f060d29cbc3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6]: /images/20221124/0a1a8ff0bc92484fb05d3bd8148a8a39.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7]: /images/20221124/8165058f1e474e82ba9a39d8c040c369.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8]: /images/20221124/f5fdd51dd8eb4f10807a75769297c966.png
[Unity AssetBundle _ _ AssetBundle]: https://download.csdn.net/download/u014361280/12720445
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9]: /images/20221124/c29816673d8041cba76fc74c8f80e2aa.png