一，可寻址系统代码加载

准备工作，创建几个预制体分别为：Cube,Capsule,Sphere，并将预制体设置为可寻址系统的资源，然后将Cube的地址修改为Cube，如下图：

1.1 回调形式

using UnityEngine;
// 引用命名空间
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class LoadManager : MonoBehaviour
{
    void Start()
    {
        // 回调形式
        LoadGameObject();
        LoadGameObjectCallBack();
        InstantiateGameObject();
    }
  
    # region 回调形式
    
    /// <summary>
    /// 加载物体 
    /// 逻辑简单且不需复用，直接使用Lambda表达式的形式
    /// </summary>
    void LoadGameObject()
    {
        // 参数："Cube" 为可寻址系统的地址
        Addressables.LoadAssetAsync<GameObject>("Cube").Completed += (obj) =>
        {
            GameObject go = obj.Result;

            Instantiate(go, Vector3.zero, Quaternion.identity);
        };
    }
    
    /// <summary>
    /// 加载物体
    /// </summary>
    void LoadGameObjectCallBack()
    {
        Addressables.LoadAssetAsync<GameObject>("Assets/Prefab/Sphere.prefab").Completed += LoadCallBack;
    }

    /// <summary>
    /// 加载物体的回调函数
    /// </summary>
    void LoadCallBack(AsyncOperationHandle<GameObject> handle)
    {
        GameObject go = handle.Result;
        Instantiate(go, Vector3.right * 2, Quaternion.identity);
    }
    
    /// <summary>
    /// 加载并实例化物体
    /// </summary>
    void InstantiateGameObject()
    {
        Addressables.InstantiateAsync("Assets/Prefab/Capsule.prefab").Completed += (obj) =>
        {
            // 已经实例化后的物体
            GameObject go = obj.Result;
            go.transform.position = Vector3.left * 2;
        };
    }
    
    #endregion   
}

运行结果如下：
成功加载三个预制

1.2 异步等待

若你不习惯回调的形式，可寻址系统也给了我们加载异步等待的形式直接去加载物体，示例代码如下：

using UnityEngine;
// 引用命名空间
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class LoadManager : MonoBehaviour
{
    void Start()
    {
        // 异步形式
        AsyncLoadCube();
        AsyncInstantiateCube();
    }
    
    #region 异步形式
    
    private async void AsyncLoadCube()
    {
        // 虽然这里使用了Task，但并没有使用多线程
        GameObject prefabObj = await Addressables.LoadAssetAsync<GameObject>("Assets/Prefabs/Cube.prefab").Task;
        // 实例化
        GameObject cubeObj = Instantiate(prefabObj);
        cubeObj.transform.position = Vector3.zero;
    }
    
    private async void AsyncInstantiateCube()
    {
         // 直接使用InstantiateAsync方法
         GameObject cubeObj = await Addressables.InstantiateAsync("Assets/Prefabs/Cube.prefab").Task;
         cubeObj.transform.position = Vector3.right * 2;
    }
    #endregion
}

运行结果如下：

1.3 面板赋值

在代码中声明AssetReference类型的变量，将上面准备好的Cube拖拽上来进行赋值。若此时拖拽上来的没有未加入可寻址系统的资源，他会自动变成一个可选寻址资源。

准备场景如下：

示例代码如下：

using UnityEngine;
// 引用命名空间
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class LoadManager : MonoBehaviour
{
    // 可寻址资源的弱引用
    public AssetReference cubeRef;
    
    void Start()
    {
        // 面板引用
        RefLoadCube();
    }  

    #region 面板形式

    void RefLoadCube()
    {
        cubeRef.LoadAssetAsync<GameObject>().Completed += (obj) =>
        {
            // 加载完成结果
            GameObject cubePrefab = obj.Result;
            // 实例化
            GameObject cubeObj = Instantiate(cubePrefab);
            // 修改位置
            cubeObj.transform.position = Vector3.zero;
        };
    }
    #endregion
}

运行结果如下：

PS：
如果我们声明的不是AssetReference类型，而是我们常用的GameObject类型，那么场景就直接依赖了Cube预制体，打包时Cube预制体就会被打到场景中。现在这里用的是AssetReference 类型，它是一个弱引用，场景并不会真的依赖Cube预制体。

1.4 同步加载

在1.17.4版本之后的可寻址系统，通过在 AsyncOperationHandle 的 WaitForCompletion 方法来实现同步加载。 WaitForCompletion 的作用是会让系统阻拦代码执行，直到资源加载完成。

同步加载GameObject的基本用法，代码如下：

using UnityEngine;
using UnityEngine.AddressableAssets; // 引用命名空间
using UnityEngine.ResourceManagement.AsyncOperations;

public class LoadManager : MonoBehaviour
{
    // Asset的弱引用
    public AssetReference cubeRef;
    
    void Start()
    {
        Addressables.InitializeAsync();
        // 同步加载
        InstantiatePrefab();
    }

    void InstantiatePrefab()
    {
        // 实例化加载到的游戏物体
        Instantiate(LoadPrefab(), transform);
    }
    
    // 强制同步加载GameObject的基本用法
    GameObject LoadPrefab()
    {
        var op = Addressables.LoadAssetAsync<GameObject>("Cube");
        GameObject go = op.WaitForCompletion();
        return go;
    }
}

多数情况下同步加载的性能和异步加载基本一致，但偶尔也会出现更快或更慢的情况。

WaitForCompletion 运算必须在引擎的任务队列中依次完成，如果小型运算的前面有一些大型运算，则只有前面的完成，系统才能完成队列后方的运算。这种情况下会出现加载慢的现象。

二，可寻址系统分标签加载

2.1 场景搭建

创建一个RawImage和一个Button摆放位置如下图：

找两张图片将其放入到工程中，并将其设置为可寻址资源，然后把地址都修改为Logo，最后分别为其创建标签Black,White 设置如下：

PS：这里创建的地址Logo和标签Black,White是下面代码中要用到的，若有变化，则代码中的值需要对应修改。

2.2 代码示例

创建如下代码并将其挂载到上面创建的RawImage物体上，并初始化如下：

下面代码，分别使用了AssetLabelReference面板赋值的形式和寻址+标签两种形式进行了分标签加载代码的示例。根据实际情况决定使用哪一种形式即可。

using System.Collections.Generic;
using UnityEngine;
// 引用命名空间
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.UI;

public class LoadByLabelManager : MonoBehaviour
{
    // 可寻址系统标签的引用
    public AssetLabelReference prefabsLabel;

    public Button loadWhiteLogoBtn;

    private RawImage _rawImage;

    void Start()
    {
        _rawImage = GetComponent<RawImage>();
        
        loadWhiteLogoBtn.onClick.AddListener(() =>
        {
            LoadTextureByKeyLabel("Logo", "Black");
        });
        
        LoadGameObjectByLabel();
    }

    /// <summary>
    /// 根据标签加载
    /// </summary>
    void LoadGameObjectByLabel()
    {
        Addressables.LoadAssetsAsync<Texture2D>(prefabsLabel, (texture) =>
        {
            // 每加载完成一个，就回调一次。 标签下有几个就会执行几次
            Debug.Log("加载完成一个资源： " + texture.name);
            _rawImage.texture = texture;
            _rawImage.SetNativeSize();
        });
    }

    /// <summary>
    /// 根据地址和标签加载
    /// </summary>
    /// <param name="key">可寻址资源地址</param>
    /// <param name="label">资源标签</param>
    void LoadTextureByKeyLabel(string key, string label)
    {
        Addressables.LoadAssetsAsync<Texture2D>(new List<string> {key, label},
            null, Addressables.MergeMode.Intersection).Completed += TextureLoaded;        
    }

    void TextureLoaded(AsyncOperationHandle<IList<Texture2D>> texture)
    {
        _rawImage.texture = texture.Result[0];
        _rawImage.SetNativeSize();
    }
}