コード例 #1
0
        public void Tick()
        {
            Assert.That(_isAsync);

            if (!_asyncQueue.IsEmpty())
            {
                // Cache the callback list to allow handlers to be added from within callbacks
                using (var block = DisposeBlock.Spawn())
                {
                    var subscriptions = block.SpawnList <SignalSubscription>();
                    subscriptions.AddRange(_subscriptions);

                    // Cache the signals so that if the signal is fired again inside the handler that it
                    // is not executed until next frame
                    var signals = block.SpawnList <object>();
                    signals.AddRange(_asyncQueue);

                    _asyncQueue.Clear();

                    for (int i = 0; i < signals.Count; i++)
                    {
                        FireInternal(subscriptions, signals[i]);
                    }
                }
            }
        }
コード例 #2
0
        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--)
                {
                    var pair = that._objectPoolPairs[i];
                    pair.Pool.Despawn(pair.Object);
                }
                ListPool <SpawnedObjectPoolPair> .Instance.Despawn(that._objectPoolPairs);

                that._objectPoolPairs = null;
            }
        }
コード例 #3
0
        public void Fire(object signal)
        {
            Assert.That(signal.GetType().DerivesFromOrEqual(_bindingId.Type));

            if (_isAsync)
            {
                _asyncQueue.Add(signal);
            }
            else
            {
                // Cache the callback list to allow handlers to be added from within callbacks
                using (var block = DisposeBlock.Spawn()) {
                    var subscriptions = block.SpawnList <SignalSubscription>();
                    subscriptions.AddRange(_subscriptions);
                    FireInternal(subscriptions, signal);
                }
            }
        }
コード例 #4
0
 static void OnSpawned(DisposeBlock that)
 {
     Assert.IsNull(that._disposables);
     Assert.IsNull(that._objectPoolPairs);
 }