Добрый день. Спасибо комментарий. информация передана.

2017-12-26T12:03:34Z

Добрый день.

Спасибо комментарий. информация передана.

3) Если эти правила регистрировать в методе protected override void OnStarted() на HistoryEmulationC...

2017-12-24T07:56:06Z

3) Если эти правила регистрировать в методе protected override void OnStarted() на HistoryEmulationConnector будет ошибка в стратегии, и стратеги работать не будет. Так как обычно на HistoryEmulationConnector сначала запускаю стратегию а после коннектор. Как то так.

Code

      private void _connector_NewSecurity(Security security)
      {
          _connector.RegisterTrades(security);

          _strategy.Start();
          _connector.Start();
      }

Соответственно на момент регистрации правила коннектор запущен не будет, и в правило не сможет получить последнюю сделку, и выдаст ошибку стратегии, которую можно увидеть только в логе. Если не вести лог стратегии можно долго гадать почему она не работает.
Эта проблема справедлива для большинства подобных правил, например, у MarketRuleHelperWhenClosePriceMore та же проблема.

вопрос 1 снимается. Оказывается надо указывать на сколько отступит цена от цены последней сделки на ...

2017-12-24T07:45:24Z

вопрос 1 снимается. Оказывается надо указывать на сколько отступит цена от цены последней сделки на момент регистрации правила, а не конкретно цену, как подумал сначала. Не очевидно конечно, но работает.

1) При следующем коде WhenLastTradePriceLess вообще ни разу не сработало, WhenLastTradePriceMore сра...

2017-12-11T09:29:24Z

1) При следующем коде WhenLastTradePriceLess вообще ни разу не сработало, WhenLastTradePriceMore срабатывает как то избирательно и очень редко. Хотя в connector.NewTrade я вижу, что сделки приходят. Как я понимаю они при таких условиях все сделки мне выдавать должны.
Коннектор КВИК.

Code


//-----------------------------------------------------------------------------------------------------------------------------------
            connector.NewTrade += (t) =>
            {
                if (t.Security == security)
                {

                }
            };
//-----------------------------------------------------------------------------------------------------------------------------------

            security.WhenLastTradePriceLess(connector, connector, new Unit(999999999m)).Do((a) =>
            {

            }).Apply();

            security.WhenLastTradePriceMore(connector, connector, new Unit(0.1m)).Do((a) =>
            {

            }).Apply();

2) Судя по исходникам правила Security.WhenLastTradePriceMore и Security.WhenLastTradePriceLess будут срабатывать не только при получении новой сделки но и при любом изменении инструмента, даже если новой сделки не было. Чем обосновано такое решение?

Code


		public static MarketRule<Security, Security> WhenBestAskPriceLess(this Security security, IConnector connector, Unit price)
		{
			return CreateSecurityCondition(security, connector, Level1Fields.BestAskPrice, price, true);
		}
		public static MarketRule<Security, Security> WhenLastTradePriceMore(this Security security, IConnector connector, IMarketDataProvider provider, Unit price)
		{
			return CreateLastTradeCondition(security, connector, provider, price, false);
		}
//-----------------------------------------------------------------------------------------------------------------------------------
		private static SecurityChangedRule CreateSecurityCondition(Security security, IConnector connector, Level1Fields field, Unit offset, bool isLess)
		{
			if (security == null)
				throw new ArgumentNullException(nameof(security));

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

			if (offset.Value == 0)
				throw new ArgumentException(LocalizedStrings.Str1051, nameof(offset));

			if (offset.Value < 0)
				throw new ArgumentException(LocalizedStrings.Str1052, nameof(offset));

			var price = (decimal?)connector.GetSecurityValue(security, field);

			if (price == null && offset.Type != UnitTypes.Limit)
				throw new InvalidOperationException(LocalizedStrings.Str1053);

			if (isLess)
			{
				var finishPrice = (decimal)(offset.Type == UnitTypes.Limit ? offset : price - offset);
				return new SecurityChangedRule(security, connector, s =>
				{
					var quote = (decimal?)connector.GetSecurityValue(s, field);
					return quote != null && quote < finishPrice;
				});
			}
			else
			{
				var finishPrice = (decimal)(offset.Type == UnitTypes.Limit ? offset : price + offset);
				return new SecurityChangedRule(security, connector, s =>
				{
					var quote = (decimal?)connector.GetSecurityValue(s, field);
					return quote != null && quote > finishPrice;
				});
			}
//-----------------------------------------------------------------------------------------------------------------------------------
		private sealed class SecurityLastTradeRule : SecurityRule<Security>
		{
			private readonly Func<Security, bool> _condition;

			public SecurityLastTradeRule(Security security, IConnector connector, Func<Security, bool> condition)
				: base(security, connector)
			{
				if (condition == null)
					throw new ArgumentNullException(nameof(condition));

				_condition = condition;

				Name = LocalizedStrings.Str1049 + " " + security;

				Connector.SecurityChanged += OnSecurityChanged;
				Connector.NewTrade += OnNewTrade;
			}

			private void OnSecurityChanged(Security security)
			{
				if (CheckLastTrade(security))
					Activate(security);
			}

			private bool CheckLastTrade(Security security)
			{
				if (Security is BasketSecurity basket)
				{
					return basket.Contains(SecurityProvider, security) && _condition(security);
				}
				else
				{
					return security == Security && _condition(Security);
				}
			}

			private void OnNewTrade(Trade trade)
			{
				if (CheckTrades(Security, trade))
					Activate(trade.Security);
			}

			private bool CheckTrades(Security security, Trade trade)
			{
				return security is BasketSecurity basket
					? basket.Contains(SecurityProvider, trade.Security) && _condition(trade.Security)
					: trade.Security == security && _condition(trade.Security);
			}

			protected override void DisposeManaged()
			{
				Connector.NewTrade -= OnNewTrade;
				Connector.SecurityChanged -= OnSecurityChanged;

				base.DisposeManaged();
			}
		}