（5）AB包资源加载管理器-同步加载

预备部分

实现部分

（1）加载方式一（未优化）

①同步加载方式一

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 知识点
/// 1.AB包先关的API
/// 2.单例模式
/// 3.委托 -> Lambda表达式
/// 4.协程
/// 5.字典
/// </summary>
public class ABMgr : SingletonAutoMono<ABMgr>
{
    //AB包管理器 目的是：让外部更方便的进行资源加载
    //主包
    private AssetBundle mainAB = null;
    //依赖包获取用的配置文件
    private AssetBundleManifest manifest = null;
    /// <summary>
    /// AB包存放路径 方便修改
    /// </summary>
    private string pathUrl
    {
        get
        {
            return Application.streamingAssetsPath + "/";
        }
    }
    /// <summary>
    /// 主包名 方便修改
    /// </summary>
    private string MainABName
    {
        get
        {
#if UNITY_IOS
                return "IOS";
#elif UNITY_ANDROID
                return "Android";
#else
            return "PC";
        }
    }
    //AB包不能够重复加载 重复加载会报错
    //字典 用字典来存储 加载过的AB包
    private Dictionary<string,AssetBundle> abDic = new Dictionary<string, AssetBundle>();//存储AB包容器
    //同步加载
    public Object LoadRes(string abName,string resName)
    {
        //加载AB包
        if(mainAB == null)
        {
            mainAB = AssetBundle.LoadFromFile(pathUrl + "PC");
            manifest = mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");//得到主包的配置文件
        }
        //获取依赖包相关信息
        AssetBundle ab;
        string[] strs = manifest.GetAllDependencies(abName);//通过配置文件得到相关依赖包
        for (int i = 0; i < strs.Length; i++)
        {
            //判断包是否加载过
            if(abDic.ContainsKey(strs[i]))
            {
                ab = AssetBundle.LoadFromFile(pathUrl + strs[i]);
                abDic.Add(strs[i], ab);
            }
        }
        //加载资源来源包(如果没有加载过，再加载)
        if (!abDic.ContainsKey(abName))
        {
            ab = AssetBundle.LoadFromFile(pathUrl + abName);
        }
        //加载资源
        return abDic[abName].LoadAsset(resName);
    }
}

②具体实现

void Start()
{
    Object obj = ABMgr.GetInstance().LoadRes("model","Cube");
    Instantiate(obj);//一定要记得实例化
}

（2）加载方式一（添加优化）

//为了外面方便 在加载资源时 判断一下 资源是不是GameObject
//如果是 直接实例化了 再返回给外部
Object obj = abDic[abName].LoadAsset(resName);
if (obj is GameObject){
    return Instantiate(obj);
}
else return obj;

Object obj = ABMgr.GetInstance().LoadRes("model","Cube") as GameObject;
obj.transform.position = Vector3.up();//得到后直接使用

（3）加载方式二（指定类型加载）

Object obj = ABMgr.GetInstance().LoadRes("model","Cube",typeof(GameObject)) as GameObject;
obj.transform.position = Vector3.up();//得到后直接使用

（4）加载方式二（指定泛型加载）

Object obj = ABMgr.GetInstance().LoadRes<GameObject>("model","Cube");
obj.transform.position = Vector3.up();//得到后直接使用

（5）以上方法汇总

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 知识点
/// 1.AB包先关的API
/// 2.单例模式
/// 3.委托 -> Lambda表达式
/// 4.协程
/// 5.字典
/// </summary>
public class ABMgr : SingletonAutoMono<ABMgr>
{
    //AB包管理器 目的是：让外部更方便的进行资源加载
    //主包
    private AssetBundle mainAB = null;
    //依赖包获取用的配置文件
    private AssetBundleManifest manifest = null;
    /// <summary>
    /// AB包存放路径 方便修改
    /// </summary>
    private string pathUrl
    {
        get
        {
            return Application.streamingAssetsPath + "/";
        }
    }
    /// <summary>
    /// 主包名 方便修改
    /// </summary>
    private string MainABName
    {
        get
        {
#if UNITY_IOS
                return "IOS";
#elif UNITY_ANDROID
                return "Android";
#else
            return "PC";
        }
    }
    //AB包不能够重复加载 重复加载会报错
    //字典 用字典来存储 加载过的AB包
    private Dictionary<string,AssetBundle> abDic = new Dictionary<string, AssetBundle>();//存储AB包容器
    /// <summary>
    /// 加载AB包
    /// </summary>
    /// <param name="abName"></param>
    private void LoadAB(string abName)
    {
        //加载AB包
        if (mainAB == null)
        {
            mainAB = AssetBundle.LoadFromFile(pathUrl + "PC");
            manifest = mainAB.LoadAsset<AssetBundleManifest>("AssetBundleManifest");//得到主包的配置文件
        }
        //获取依赖包相关信息
        AssetBundle ab;
        string[] strs = manifest.GetAllDependencies(abName);//通过配置文件得到相关依赖包
        for (int i = 0; i < strs.Length; i++)
        {
            //判断包是否加载过
            if (abDic.ContainsKey(strs[i]))
            {
                ab = AssetBundle.LoadFromFile(pathUrl + strs[i]);
                abDic.Add(strs[i], ab);
            }
        }
        //加载资源来源包(如果没有加载过，再加载)
        if (!abDic.ContainsKey(abName))
        {
            ab = AssetBundle.LoadFromFile(pathUrl + abName);
        }
    }
    //同步加载 不指定类型
    public Object LoadRes(string abName,string resName)
    {
        LoadAB(abName);//加载AB包
        //为了外面方便 在加载资源时 判断一下 资源是不是GameObject
        //如果是 直接实例化了 再返回给外部
        Object obj = abDic[abName].LoadAsset(resName);
        if (obj is GameObject){
            return Instantiate(obj);
        }
        else return obj;
    }
    //同步加载 根据type指定类型
    public Object LoadRes(string abName, string resName,System.Type type)
    {
        LoadAB(abName);//加载AB包
        //为了外面方便 在加载资源时 判断一下 资源是不是GameObject
        //如果是 直接实例化了 再返回给外部
        Object obj = abDic[abName].LoadAsset(resName,type);
        if (obj is GameObject)
        {
            return Instantiate(obj);
        }
        else return obj;
    }
    //同步加载 根据泛型指定类型
    public T LoadRes<T>(string abName, string resName) where T:Object
    {
        LoadAB(abName);//加载AB包
        //为了外面方便 在加载资源时 判断一下 资源是不是GameObject
        //如果是 直接实例化了 再返回给外部
        T obj = abDic[abName].LoadAsset<T>(resName);
        if (obj is GameObject)
        {
            return Instantiate(obj);
        }
        else return obj;
    }
    //单个包卸载
    public void UnLoad(string abName)
    {
        if(abDic.ContainsKey(abName))
        {
            abDic[abName].Unload(false);
            abDic.Remove(abName);
        }
    }
    //所有包的卸载
    public void ClearAB()
    {
        AssetBundle.UnloadAllAssetBundles(false);
        abDic.Clear();
        mainAB = null;
        manifest = null;
    }    
}