static void OnDespawned(DisposeBlock that)
        {
            if (that._disposables != null)
            {
                // Dispose in reverse order since usually that makes the most sense
                for (int i = that._disposables.Count - 1; i >= 0; i--)
                {
                    that._disposables[i].Dispose();
                }
                ListPool <IDisposable> .Instance.Despawn(that._disposables);

                that._disposables = null;
            }

            if (that._objectPoolPairs != null)
            {
                // Dispose in reverse order since usually that makes the most sense
                for (int i = that._objectPoolPairs.Count - 1; i >= 0; i--)
                {
                    SpawnedObjectPoolPair pair = that._objectPoolPairs[i];
                    pair.Pool.Despawn(pair.Object);
                }
                ListPool <SpawnedObjectPoolPair> .Instance.Despawn(that._objectPoolPairs);

                that._objectPoolPairs = null;
            }
        }
Exemple #2
0
        void StoreSpawnedObject <T>(T obj, IDespawnableMemoryPool <T> pool)
        {
            if (typeof(T).DerivesFrom <IDisposable>())
            {
                Add((IDisposable)obj);
            }
            else
            {
                // This allocation is ok because it's a struct
                var pair = new SpawnedObjectPoolPair
                {
                    Pool   = pool,
                    Object = obj
                };

                if (_objectPoolPairs == null)
                {
                    _objectPoolPairs = ListPool <SpawnedObjectPoolPair> .Instance.Spawn();
                }
                _objectPoolPairs.Add(pair);
            }
        }