Скорость тестирования снизилась в 4 раза

using System.Collections.Concurrent;
using StockSharp.Algo;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;

namespace AlgoTrading.SpeedTest
{
    public class MyQuotingStrategy : Strategy
    {
        private readonly ConcurrentStack<Order> _orders = new ConcurrentStack<Order>();
        private readonly OrderDirections _orderDirection;
        private readonly Unit _startPrice;
        private readonly Unit _offset;
        private readonly object _locker = new object();
        private bool _canCancel;

        public MyQuotingStrategy(OrderDirections orderDirection, Unit price, Unit offset)
        {
            _orderDirection = orderDirection;
            _startPrice = price;
            _offset = offset;
        }

        protected override void OnStarted()
        {
            Security
                .WhenMarketDepthChanged()
                .Do(depth =>
                {
                    Order order;
                    _orders.TryPeek(out order);

                    if (order != null && order.State == OrderStates.Active && _canCancel)
                    {
                        var cancelOrder = _orderDirection == OrderDirections.Buy && depth.BestBid != null &&
                                           depth.BestBid.Price > order.Price || _orderDirection == OrderDirections.Sell && depth.BestAsk != null &&
                                           depth.BestAsk.Price < order.Price;

                        if (cancelOrder)
                        {
                            _canCancel = false;
                            order.WhenCanceled().Do(o => RegisterNew(o.Balance,
                                                                     _orderDirection == OrderDirections.Buy
                                                                         ? new Unit(depth.BestBid.Price, UnitTypes.Absolute, Security)
                                                                         : new Unit(depth.BestAsk.Price, UnitTypes.Absolute, Security)))
                                .Once()
                                .Sync(_locker)
                                .Apply(this);
                            CancelOrder(order);
                        }
                    }
                })
                .Sync(_locker)
                .Apply(this);

            RegisterNew(Volume, _startPrice);
            base.OnStarted();
        }

        private void RegisterNew(decimal volume, Unit price)
        {
            var order = new Order()
            {
                Direction = _orderDirection,
                Price = price.ApplyOffset(_orderDirection, _offset),
                Volume = volume,
            };

            order.WhenRegistered().Do(o => _canCancel = true )
            .Once()
            .Sync(_locker)
            .Apply(this);

            order.WhenMatched().Do(o => Stop())
            .Once()
            .Sync(_locker)
            .Apply(this);

            RegisterOrder(order);
            _orders.Push(order);
        }
    }
}

using StockSharp.Algo;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;

namespace AlgoTrading.SpeedTest
{
    public class MarketDepthSkeleton : Strategy
    {
        private OrderDirections? _orderDirection;
        private bool _canProcess = true;
        private readonly object _locker = new object();

        protected override void OnStarted()
        {
            Security
                .WhenMarketDepthChanged()
                .Do(ProcessDepth)
                .Sync(_locker)
                .Apply(this);

            base.OnStarted();
        }

        private void ProcessDepth(MarketDepth depth)
        {
            if (Security.BestAsk == null || Security.BestBid == null)
                return;

            if (_canProcess)
            {
                _canProcess = false;
                _orderDirection = _orderDirection.HasValue ? _orderDirection.Value.Invert() : OrderDirections.Buy;
                var price = depth.GetCurrentPrice(_orderDirection.Value).Value;
                var strategy = new MyQuotingStrategy(_orderDirection.Value,
                                                     new Unit(price, UnitTypes.Absolute, Security),
                                                     new Unit(1, UnitTypes.Step, Security)) { Volume = Volume };
                strategy.WhenStopped().Do(() => _canProcess = true).Once().Sync(_locker).Apply(this);
                ChildStrategies.Add(strategy);
            }
        }
    }
}