public void Remove(ILoadBalanced item)
 {
     LoadBalancedQueue.LoadBalancerItem loadBalancerItem = this._queue.Remove((LoadBalancedQueue.LoadBalancerItem o) => o.item == item);
     if (loadBalancerItem != null)
     {
         loadBalancerItem.Dispose();
     }
 }
        public void Update()
        {
            if (!this._queue.hasNext)
            {
                return;
            }
            float single = Time.time;

            this._watch.Reset();
            this._watch.Start();
            int   num     = this.maxUpdatesPerInterval;
            int   num1    = 0;
            float single1 = 0f;

            if (this.autoAdjust)
            {
                float single2 = this.defaultUpdateInterval / Time.deltaTime;
                num = Mathf.CeilToInt((float)this._queue.count / single2);
            }
            LoadBalancedQueue.LoadBalancerItem loadBalancerItem = this._queue.Peek();
            while (true)
            {
                int num2 = num1;
                num1 = num2 + 1;
                if (num2 >= num || loadBalancerItem.nextUpdate > single || !this.autoAdjust && this._watch.ElapsedMilliseconds >= (long)this.maxUpdateTimeInMillisecondsPerUpdate)
                {
                    break;
                }
                float single3 = single - loadBalancerItem.lastUpdate;
                single1 = single1 + (single3 - loadBalancerItem.interval);
                float?nullable       = loadBalancerItem.item.ExecuteUpdate(single3, loadBalancerItem.interval);
                float valueOrDefault = nullable.GetValueOrDefault(loadBalancerItem.interval);
                if (!loadBalancerItem.item.repeat)
                {
                    this._queue.Remove().Dispose();
                }
                else
                {
                    valueOrDefault = Mathf.Max(valueOrDefault, 0.01f);
                    loadBalancerItem.lastUpdate = single;
                    loadBalancerItem.nextUpdate = single + valueOrDefault;
                    this._queue.ReheapifyDownFrom(0);
                }
                if (!this._queue.hasNext)
                {
                    break;
                }
                loadBalancerItem = this._queue.Peek();
            }
            this.updatedItemsCount      = num1 - 1;
            this.updatesOverdueByTotal  = single1;
            this.updateMillisecondsUsed = this._watch.ElapsedMilliseconds;
        }
        public ILoadBalancedHandle Add(ILoadBalanced item, float interval, float delayFirstUpdateBy)
        {
            float single = Time.time;

            LoadBalancedQueue.LoadBalancerItem loadBalancerItem = new LoadBalancedQueue.LoadBalancerItem()
            {
                parent     = this,
                lastUpdate = single,
                nextUpdate = single + delayFirstUpdateBy,
                interval   = interval,
                item       = item
            };
            this._queue.Add(loadBalancerItem);
            return(loadBalancerItem);
        }
 private void Remove(LoadBalancedQueue.LoadBalancerItem item)
 {
     this._queue.Remove(item);
 }