AddressableをIDisposableで管理する

Addressable、めっちゃ便利だけどAsyncOperationHandleを握っておいてReleaseメソッドを呼ぶ。という開放がちょっと面倒なんですよね。
そこで、IDisposableで管理できるようにしてみました。

合わせて読みたい -> EditorではAddressableのロードを早くする

使い方

// 読み込む
var prefab = await AddressableWrapper.Load<GameObject>("Test.prefab", cancellationToken);

// 使う
GameObject.Instantiate(prefab.Value);

// 開放する
prefab.Dispose();

コード

AddressableWrapper.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71using System;
using System.Threading;
using Cysharp.Threading.Tasks;
using JetBrains.Annotations;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

namespace KyubunsSandbox
{
    public static class AddressableWrapper
    {
        private static IAddressableLoader _addressableLoader;

        public static IAddressableLoader AddressableLoader
        {
            get => _addressableLoader ?? (_addressableLoader = new DefaultAddressableLoader());
            set => _addressableLoader = value;
        }

        [MustUseReturnValue]
        public static UniTask<IDisposableAsset<TObject>> Load<TObject>(string address, CancellationToken cancellationToken) where TObject : UnityEngine.Object
        {
            return AddressableLoader.LoadAssetAsync<TObject>(address, cancellationToken);
        }

        public interface IAddressableLoader
        {
            UniTask<IDisposableAsset<TObject>> LoadAssetAsync<TObject>(string address, CancellationToken cancellationToken) where TObject : UnityEngine.Object;
        }

        public class DefaultAddressableLoader : IAddressableLoader
        {
            public async UniTask<IDisposableAsset<TObject>> LoadAssetAsync<TObject>(string address, CancellationToken cancellationToken) where TObject : UnityEngine.Object
            {
                var handle = Addressables.LoadAssetAsync<TObject>(address);
                await handle.ToUniTask(cancellationToken: cancellationToken);
                if (handle.Status == AsyncOperationStatus.Succeeded)
                {
                    return new DisposableAsset<TObject>(handle.Result, () => Addressables.Release(handle));
                }
                throw new Exception($"Failed to load {address} {handle.Status}");
            }
        }
    }

    public interface IDisposableAsset<out T> : IDisposable
    {
        T Value { get; }
    }

    public class DisposableAsset<T> : IDisposableAsset<T>
    {
        public T Value { get; }

        private bool _disposed;
        private readonly Action _dispose;

        public DisposableAsset(T value, Action dispose)
        {
            Value = value;
            _dispose = dispose;
        }

        public void Dispose()
        {
            if (_disposed) return;
            _disposed = true;
            _dispose();
        }
    }
}