orders delay

        public decimal CurrentPos;
        private Object _lockObjCurrentPos = new Object();
        private SynchronizedDictionary<Order, OrderInfo> _ordersInfo = new SynchronizedDictionary<Order, OrderInfo>();
        public OrderInfo OrderInfo(Order order)
        {
            return _ordersInfo.SyncGet(o => o.FirstOrDefault(t => t.Key == order)).Value;
        }

        // Ордера которые отправляются с задержкой.
        protected SortedList<Order, DateTime> _delayedOrders = new SortedList<Order, DateTime>();
        private Object _lockObjDelayedOrders = new Object();

        public void OnMarketTimeChanged()
        {
            List<Order> orders = new List<Order>();

            var processOrders = _delayedOrders.Where(p => p.Value <= TraderManager.MarketTime);

            if (processOrders.Count() == 0)
                return;

            lock (_lockObjDelayedOrders)
            {
                foreach (var pair in processOrders)                
                    orders.Add(pair.Key);

                foreach (var order in orders)
                    _delayedOrders.RemoveWhere(p => p.Key.Id == order.Id);
            }

            foreach (var order in orders)
            {
                lock (_lockObjCurrentPos)
                {
                    CurrentPos += order.Volume * (order.Direction == OrderDirections.Buy ? 1 : -1);
                }
                                
                base.RegisterOrder(order);
            }
        }

        public virtual void MyCreateOrder(OrderDirections direction, string comment = "", decimal price = 0, decimal volume = 0, TimeSpan _delay = new TimeSpan())
        {   
            var priceLocal = price;

            if (volume == 0)
                volume = base.Volume;
            if (priceLocal == 0)
            {               
                priceLocal = Security.LastTrade.Price + 1000 * (direction == OrderDirections.Buy ? 1 : -1);              
            }

            var order = this.CreateOrder(direction, priceLocal, volume);

            var timePlan = MarketTime;            
                        
            _ordersInfo.SyncDo(o => o.Add(order, new OrderInfo
                               {
                                   Comment = comment,
                                   PricePlan = price == 0 ? candleList.Last().ClosePrice : price,
                                   TimePlan = timePlan
                               }));
            
            try
            {   
                if (_delay == new TimeSpan())
                {
                    lock (_lockObjCurrentPos)
                    {
                        CurrentPos += order.Volume * (order.Direction == OrderDirections.Buy ? 1 : -1);
                    }                    

                    base.RegisterOrder(order);
                }
                else
                {
                    _delayedOrders.Add(order, TraderManager.MarketTime + _delay);
                }                
            }
            catch (Exception e)
            {
                LoggingHelper.AddErrorLog(this, e);
            }            
        }