addressables.cs

        private IEnumerator LoadObjects<TObject>(IList<object> keys, Addressables.MergeMode mergeMode = Addressables.MergeMode.Union)
        {
                var locations = Addressables.LoadResourceLocationsAsync(keys, mergeMode, typeof(TObject));

                yield return locations;

                var asyncOperationHandles = new List<AsyncOperationHandle>(locations.Result.Count);
                
                foreach (var location in locations.Result)
                {
                        if (_allObjectAsyncOperationHandlesByLocationKey.ContainsKey(location.PrimaryKey))
                        {
                                continue;
                        }
                        
                        var asyncOperationHandle = Addressables.LoadAssetAsync<TObject>(location);

                        asyncOperationHandle.Completed += obj =>
                        {
                                if (obj.Status == AsyncOperationStatus.Succeeded)
                                {
                                        _allObjectAsyncOperationHandlesByLocationKey.Add(location.PrimaryKey, obj);
                                        _allAddressableLocationKeysByObject.Add(obj.Result, location.PrimaryKey);

                                        if (obj.Result is GameObject gameObj) OnGameObjectLoaded?.Invoke(gameObj);
                                }
                                else
                                {
                                        // TODO: 
                                }
                        };
                        
                        asyncOperationHandles.Add(asyncOperationHandle);
                }

                yield return Addressables.ResourceManager.CreateGenericGroupOperation(asyncOperationHandles, true);
        }
        
        private IEnumerator UnloadObjects(List<object> objs)
        {
                var keys = new List<string>();
                foreach (var obj in objs)
                {
                        if (_allAddressableLocationKeysByObject.ContainsKey(obj))
                        {
                                keys.Add(_allAddressableLocationKeysByObject[obj]);
                        }
                }
                
                foreach (var key in keys)
                {
                        if (!_allObjectAsyncOperationHandlesByLocationKey.ContainsKey(key))
                        {
                                continue;
                        }

                        var asyncOperationHandle = _allObjectAsyncOperationHandlesByLocationKey[key];

                        if (asyncOperationHandle.Result is GameObject gameObj) OnGameObjectUnloaded?.Invoke(gameObj);
                        
                        _allObjectAsyncOperationHandlesByLocationKey.Remove(key);
                        
                        _allAddressableLocationKeysByObject.Remove(asyncOperationHandle.Result);
                        
                        Addressables.Release(asyncOperationHandle);
                }

                yield return true; // Return true only so that this method can be queued as a coroutine (same as loading)
        }