public void Remove(Order order)
				{
					if (order == null)
						throw new ArgumentNullException(nameof(order));

					_orders.Remove(order);
				}

		public CancelOrderCommand(Order mask)
		{
			if (mask == null)
				throw new ArgumentNullException("mask");

			Mask = mask;
		}

		public RegisterOrderCommand(Order order)
		{
			if (order == null)
				throw new ArgumentNullException(nameof(order));

			Order = order;
		}

				public void Add(Order order)
				{
					if (order == null)
						throw new ArgumentNullException(nameof(order));

					_orders.Add(order);
				}

		/// <summary>
		/// Перерегистрировать заявку на бирже.
		/// </summary>
		/// <param name="oldOrder">Заявка, которую нужно снять.</param><param name="newOrder">Новая заявка, которую нужно зарегистрировать.</param>
		protected override void OnReRegisterOrder(Order oldOrder, Order newOrder)
		{
			if (oldOrder.Security.Board.IsSupportAtomicReRegister)
			{
				var newOrderId1 = oldOrder.Id;
				var newOrderId2 = 0L;

				string res;
				var resCode = _slot.MoveOrders(1, ref newOrderId1, (double)newOrder.Price, (int)newOrder.Volume,
				                              newOrder.TransactionId.To<string>(), ref newOrderId2, 0, 0, "", out res);

				var exception = AlorExceptionHelper.GetException(resCode, res);

				if (exception != null)
				{
					RaiseOrderFailed(newOrder, exception);
					RaiseOrderFailed(oldOrder, exception);
				}

				newOrder.Messages.Add(res);
			}
			else
			{
				base.OnReRegisterOrder(oldOrder, newOrder);
			}
		}

		public OrderCommand(Order order, OrderActions action)
		{
			if (order == null)
				throw new ArgumentNullException(nameof(order));

			Order = order;
			Action = action;
		}

			public void ProcessChangedOrder(Order order)
			{
				var container = GetContainer(order);

				if (order.State == OrderStates.Done)
					container.Remove(order);

				container.RefreshTotals();
			}

			public void ProcessNewOrder(Order order)
			{
				var container = GetContainer(order);

				if (order.State == OrderStates.Active)
				{
					container.Add(order);
					container.RefreshTotals();
				}
			}

		public ReRegisterOrderCommand(Order oldOrder, Order newOrder)
		{
			if (oldOrder == null)
				throw new ArgumentNullException(nameof(oldOrder));

			if (newOrder == null)
				throw new ArgumentNullException(nameof(newOrder));

			OldOrder = oldOrder;
			NewOrder = newOrder;
		}

		/// <summary>
		/// Зарегистрировать заявку на бирже.
		/// </summary>
		/// <param name="order">Заявка, содержащая информацию для регистрации.</param>
		protected override void OnRegisterOrder(Order order)
		{
			string exexCondition;

			switch (order.TimeInForce)
			{
				case TimeInForce.PutInQueue:
					exexCondition = " ";
					break;
				case TimeInForce.MatchOrCancel:
					exexCondition = "N";
					break;
				case TimeInForce.CancelBalance:
					exexCondition = "W";
					break;
				default:
					throw new ArgumentOutOfRangeException();
			}

			const string enterType = "P";
			const string splitFlag = "S";
			const string issueCode = "";

			var direction = order.Direction == OrderDirections.Buy ? "B" : "S";
			var extRef = order.TransactionId.To<String>();

			int resCode;
			string res;

			if (order.Type == OrderTypes.Conditional)
			{
				var condition = (AlorOrderCondition)order.Condition;
				resCode = _slot.AddStopOrder(order.Portfolio.Name, direction, order.Price == 0 ? "M" : "L", splitFlag,
				                            exexCondition, enterType, order.Security.Board.Code, order.Security.Code, issueCode,
				                            condition.Type.ToAlorConditionType(), order.ExpiryDate,
				                            (double)condition.StopPrice, (double)order.Price, (int)order.Volume, _slot.BrokerRef, extRef, out res);
			}
			else
			{

				resCode = _slot.AddOrder(order.Portfolio.Name, direction,
				                        order.Type == OrderTypes.Market ? "M" : "L", splitFlag, exexCondition, enterType, order.Security.Board.Code,
				                        order.Security.Code, issueCode, (double)order.Price, (int)order.Volume, _slot.BrokerRef, extRef, out res);
			}

			var exception = AlorExceptionHelper.GetException(resCode, res);
			if (exception != null)
				RaiseOrderFailed(order, exception);

			order.Messages.Add(res);
		}

		private void OrderGrid_OnOrderReRegistering(Order order)
		{
			var window = new OrderWindow
			{
				Title = LocalizedStrings.Str2976Params.Put(order.TransactionId),
				Connector = MainWindow.Instance.Trader,
				Order = order.ReRegisterClone(newVolume: order.Balance),
			};

			if (window.ShowModal(this))
			{
				MainWindow.Instance.Trader.ReRegisterOrder(order, window.Order);
			}
		}

		private void DeleteOrder(Order order)
		{
			if (order != null)
			{
				try
				{
					Connector.CancelOrder(order);
				}
				catch (Exception g)
				{
					Debug.Print("{0}", g);
				}
			}
		}

		private void OrderGrid_OnOrderReRegistering(Order order)
		{
			var window = new OrderWindow
			{
				Title = LocalizedStrings.Str2976Params.Put(order.TransactionId),
				SecurityProvider = MainWindow.Instance.Trader,
				MarketDataProvider = MainWindow.Instance.Trader,
				Portfolios = new PortfolioDataSource(MainWindow.Instance.Trader),
				Order = order.ReRegisterClone(newVolume: order.Balance),
			};

			if (window.ShowModal(this))
			{
				MainWindow.Instance.Trader.ReRegisterOrder(order, window.Order);
			}
		}

        protected override void OnStarted()
        {
            var order = new Order
            {
                Type = OrderTypes.Limit,
                Portfolio = Portfolio,
                Volume = 100,
                Price = price,
                Security = Security,
                Direction = sides
            };

            Connector.RegisterOrder(order);

            base.OnStarted();
        }     

		/// <summary>
		/// The method is called when a new order added.
		/// </summary>
		/// <param name="order">Order.</param>
		protected override void OnOrderAdded(Order order)
		{
			if (order.Type != OrderTypes.Conditional)
				return;

			Type conditionType;

			lock (_conditionTypes.SyncRoot)
			{
				var condition = order.Condition;

				if (condition == null)
					return;

				conditionType = condition.GetType();

				if (_conditionTypes.Contains(conditionType))
					return;

				_conditionTypes.Add(conditionType);
			}

			GuiDispatcher.GlobalDispatcher.AddAction(() => AddColumns(conditionType));
		}

		private void SpeedTestStrategyOrderRegistered(Order order)
		{
			lock (_locker)
			{
				if (order.LatencyRegistration != null)
					_holeTime += order.LatencyRegistration.Value;

				NumberOfOrders++;

				if (OrderTimeChanged != null)
					OrderTimeChanged();

				DeleteOrder(order);

				if (NumberOfOrders < _nummberofTests)
				{
					RegisterOrder(SendNewOrder());
				}
				else
				{
					Stop();
				}
			}
		}

		protected override void AssignOrderStrategyId(Order order)
		{
			order.UserOrderId = this.GetStrategyId().To<string>();
		}

		/// <summary>
		/// Отменить заявку на бирже.
		/// </summary>
		/// <param name="order">Заявка, которую нужно отменять.</param>
		protected override void OnCancelOrder(Order order)
		{
			var id = order.Id;
			string res;
			var resCode = order.Type == OrderTypes.Conditional
				              ? _slot.DeleteStopOrder(id, out res)
				              : _slot.DeleteOrder(id, out res);

			var exception = AlorExceptionHelper.GetException(resCode, res);

			if (exception != null)
				RaiseOrderFailed(order, exception);

			order.Messages.Add(res);
		}

		private void AddOrder(Order order)
		{
			if (OrdersKeepCount == 0)
				return;

			_orders.Add(order);
			RecycleOrders();
		}

			/// <summary>
			/// Отменить заявку на бирже.
			/// </summary>
			/// <param name="order">Заявка, которую нужно отменять.</param>
			/// <param name="transactionId">Идентификатор транзакции отмены.</param>
			protected override void OnCancelOrder(Order order, long transactionId)
			{
				_realConnector.SendInMessage(order.CreateCancelMessage(_realConnector.GetSecurityId(order.Security), transactionId));
			}