Estrategia de Day Trading Trend Pullback

Descripción general

La Estrategia de Day Trading es un sistema de seguimiento de tendencia que entra en retrocesos dentro de una dirección establecida. El asesor experto original (entrada MQL MQL/24298/Day Trading.mq4) mezcla un filtro de tendencia EMA de 100 períodos con momentum y una confirmación MACD de marco temporal superior. El port de StockSharp mantiene la misma idea mientras expone cada entrada importante como un parámetro de estrategia.

La estrategia opera en un único instrumento y un tipo de vela configurable. Nunca coloca órdenes pendientes – todas las operaciones se ejecutan a mercado una vez que las condiciones en la última vela terminada se satisfacen. Los niveles protectores de stop-loss y take-profit se adjuntan inmediatamente después de la entrada.

Lógica de trading

Calificación de tendencia – El mínimo de cada una de las últimas TrendConfirmationCount velas debe cerrar por encima de la EMA de 100 períodos para permitir configuraciones largas. Para cortos, los máximos de la ventana de lookback deben permanecer por debajo de la EMA. Esto reproduce el helper candles() del EA original.
Verificación de retroceso – Una operación solo puede ocurrir si al menos una de las tres velas anteriores retrocedió a la EMA de 20 períodos. Para operaciones largas el mínimo debe perforar por debajo de la EMA, mientras que las cortas requieren que el mínimo se mantenga por encima de la EMA (el código MQL usaba Low > EMA20 para filtros cortos y la misma comparación se mantiene aquí).
Filtro de momentum – El Momentum (período MomentumPeriod) debe desviarse del valor neutro de 100 por más de MomentumThreshold en cualquiera de las tres últimas velas completadas. La desviación se mide como abs(momentum - 100).
Confirmación MACD mensual – El port abre posiciones solo cuando la línea principal del MACD mensual está por encima de la línea de señal para largos o por debajo para cortos. El MACD se evalúa en la suscripción MacdCandleType (mensual por defecto) y reutiliza la configuración clásica 12/26/9.
Dimensionamiento de posición – Cada nueva orden usa Volume lotes. El tamaño neto de la posición nunca supera Volume * MaxPositions. Cuando la señal se invierte mientras hay una posición abierta, la estrategia invierte la posición combinando los volúmenes de cierre y apertura en una sola orden de mercado.
Gestión de riesgo – Justo después de una ejecución, la estrategia almacena precios fijos de stop-loss y take-profit calculados desde StopLossPips y TakeProfitPips. Cada vela terminada verifica si algún nivel ha sido alcanzado y cierra la posición si es necesario.

Parámetros

Nombre	Descripción	Predeterminado
`Volume`	Tamaño base de la orden. El valor se normaliza al paso de volumen del instrumento.	`1`
`CandleType`	Marco temporal de trabajo.	`TimeSpan.FromMinutes(15).TimeFrame()`
`MacdCandleType`	Marco temporal usado por la confirmación MACD.	`TimeSpan.FromDays(30).TimeFrame()`
`TrendConfirmationCount`	Número de velas que deben permanecer en el lado correcto de la EMA de 100. Refleja el input `Count` del EA.	`10`
`MomentumPeriod`	Período del indicador de momentum.	`14`
`MomentumThreshold`	Distancia absoluta mínima del momentum desde 100 para permitir entradas.	`0.3`
`StopLossPips`	Distancia de stop-loss en pips.	`20`
`TakeProfitPips`	Distancia de take-profit en pips.	`50`
`MaxPositions`	Número máximo de lotes base que pueden acumularse en una dirección.	`10`

Notas de implementación

Los bindings de indicadores se realizan con la API de alto nivel. La suscripción principal de velas proporciona valores de EMA20/60/100 y momentum, mientras que la suscripción mensual alimenta el filtro MACD via BindEx.
Todas las colecciones que replican los lookbacks de MQL (flags de retroceso, flags de tendencia EMA, desviaciones de momentum) se implementan como colas rodantes para que no se acceda directamente al historial crudo del indicador.
Los stops y objetivos se verifican en cada vela terminada. El helper que convierte pips a precios adapta el tamaño del pip del instrumento PriceStep, reproduciendo el cálculo de pips usado en el EA.
La estrategia usa StartProtection() en OnStarted para que el bloque de protección integrado esté habilitado antes de que se envíen órdenes.

Diferencias de conversión

El experto original realizaba numerosas tareas de gestión de balance (equity stop, interruptores de break-even, trailing personalizado). Solo se portaron las partes deterministas de la lógica de entrada/salida. Los usuarios de StockSharp pueden extender la clase si se requieren esas reglas de gestión de dinero.
Las notificaciones de correo, push y las anotaciones de gráfico presentes en el archivo MQL se omiten intencionalmente.
Debido a que StockSharp trabaja con posiciones agregadas, MaxPositions limita la exposición neta absoluta en lugar del conteo de órdenes en bruto.

Uso

Adjuntar la estrategia a un conector que proporcione el instrumento deseado y datos de velas para el marco temporal de trading y el de confirmación MACD.
Ajustar los parámetros según la volatilidad del activo y la tolerancia al riesgo. Aumentar TrendConfirmationCount o MomentumThreshold hace las entradas más selectivas.
Iniciar la estrategia. Las órdenes se generarán automáticamente una vez que todos los filtros se alineen en una vela terminada.

Archivos

CS/DayTradingStrategy.cs – Implementación StockSharp.
README_ru.md – Descripción en ruso.
README_zh.md – Descripción en chino.

using System; using System.Collections.Generic; using Ecng.Common; using StockSharp.Algo.Indicators; using StockSharp.Algo.Strategies; using StockSharp.BusinessEntities; using StockSharp.Messages; namespace StockSharp.Samples.Strategies; public class DayTradingTrendPullbackStrategy : Strategy { private readonly StrategyParam<int> _fastPeriod; private readonly StrategyParam<int> _slowPeriod; private readonly StrategyParam<int> _stopLossPoints; private readonly StrategyParam<int> _takeProfitPoints; private ExponentialMovingAverage _fast; private ExponentialMovingAverage _slow; private decimal _prevFast; private decimal _prevSlow; private decimal _entryPrice; private int _cooldown; public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; } public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; } public int StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; } public int TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; } public DayTradingTrendPullbackStrategy() { _fastPeriod = Param(nameof(FastPeriod), 14).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator"); _slowPeriod = Param(nameof(SlowPeriod), 50).SetGreaterThanZero().SetDisplay("Slow Period", "Slow EMA period", "Indicator"); _stopLossPoints = Param(nameof(StopLossPoints), 200).SetNotNegative().SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk"); _takeProfitPoints = Param(nameof(TakeProfitPoints), 400).SetNotNegative().SetDisplay("Take Profit", "Take-profit in price steps", "Risk"); } public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities() { yield return (Security, TimeSpan.FromMinutes(5).TimeFrame()); } protected override void OnReseted() { base.OnReseted(); _fast = null; _slow = null; _prevFast = 0; _prevSlow = 0; _entryPrice = 0; _cooldown = 0; } protected override void OnStarted2(DateTime time) { base.OnStarted2(time); _fast = new ExponentialMovingAverage { Length = FastPeriod }; _slow = new ExponentialMovingAverage { Length = SlowPeriod }; var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame()); subscription.Bind(_fast, _slow, ProcessCandle); subscription.Start(); } private void ProcessCandle(ICandleMessage candle, decimal fastValue, decimal slowValue) { if (candle.State != CandleStates.Finished) return; if (!_fast.IsFormed || !_slow.IsFormed) { _prevFast = fastValue; _prevSlow = slowValue; return; } if (_cooldown > 0) { _cooldown--; _prevFast = fastValue; _prevSlow = slowValue; return; } var close = candle.ClosePrice; var step = Security?.PriceStep ?? 1m; if (Position > 0 && _entryPrice > 0) { if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; } if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; } } else if (Position < 0 && _entryPrice > 0) { if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; } if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; } } if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0) { if (Position < 0) BuyMarket(); BuyMarket(); _entryPrice = close; _cooldown = 100; } else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0) { if (Position > 0) SellMarket(); SellMarket(); _entryPrice = close; _cooldown = 100; } _prevFast = fastValue; _prevSlow = slowValue; } }

import clr clr.AddReference("StockSharp.Messages") clr.AddReference("StockSharp.Algo") clr.AddReference("StockSharp.Algo.Indicators") clr.AddReference("StockSharp.Algo.Strategies") from System import TimeSpan from StockSharp.Messages import DataType, CandleStates from StockSharp.Algo.Indicators import ExponentialMovingAverage from StockSharp.Algo.Strategies import Strategy class day_trading_trend_pullback_strategy(Strategy): def __init__(self): super(day_trading_trend_pullback_strategy, self).__init__() self._fast_period = self.Param("FastPeriod", 14) \ .SetDisplay("Fast Period", "Fast MA period", "Indicator") self._slow_period = self.Param("SlowPeriod", 50) \ .SetDisplay("Slow Period", "Slow MA period", "Indicator") self._stop_loss_points = self.Param("StopLossPoints", 200) \ .SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk") self._take_profit_points = self.Param("TakeProfitPoints", 400) \ .SetDisplay("Take Profit", "Take-profit in price steps", "Risk") self._fast = None self._slow = None self._prev_fast = 0.0 self._prev_slow = 0.0 self._entry_price = 0.0 self._cooldown = 0 @property def fast_period(self): return self._fast_period.Value @property def slow_period(self): return self._slow_period.Value @property def stop_loss_points(self): return self._stop_loss_points.Value @property def take_profit_points(self): return self._take_profit_points.Value def OnReseted(self): super(day_trading_trend_pullback_strategy, self).OnReseted() self._fast = None self._slow = None self._prev_fast = 0.0 self._prev_slow = 0.0 self._entry_price = 0.0 self._cooldown = 0 def OnStarted2(self, time): super(day_trading_trend_pullback_strategy, self).OnStarted2(time) self._fast = ExponentialMovingAverage() self._fast.Length = self.fast_period self._slow = ExponentialMovingAverage() self._slow.Length = self.slow_period subscription = self.SubscribeCandles(DataType.TimeFrame(TimeSpan.FromMinutes(5))) subscription.Bind(self._fast, self._slow, self._process_candle) subscription.Start() def _process_candle(self, candle, fast_value, slow_value): if candle.State != CandleStates.Finished: return fast_val = float(fast_value) slow_val = float(slow_value) if not self._fast.IsFormed or not self._slow.IsFormed: self._prev_fast = fast_val self._prev_slow = slow_val return if self._cooldown > 0: self._cooldown -= 1 self._prev_fast = fast_val self._prev_slow = slow_val return close = float(candle.ClosePrice) step = float(self.Security.PriceStep) if self.Security is not None and self.Security.PriceStep is not None else 1.0 if self.Position > 0 and self._entry_price > 0: if self.stop_loss_points > 0 and close <= self._entry_price - self.stop_loss_points * step: self.SellMarket() self._entry_price = 0.0 self._cooldown = 100 self._prev_fast = fast_val self._prev_slow = slow_val return if self.take_profit_points > 0 and close >= self._entry_price + self.take_profit_points * step: self.SellMarket() self._entry_price = 0.0 self._cooldown = 100 self._prev_fast = fast_val self._prev_slow = slow_val return elif self.Position < 0 and self._entry_price > 0: if self.stop_loss_points > 0 and close >= self._entry_price + self.stop_loss_points * step: self.BuyMarket() self._entry_price = 0.0 self._cooldown = 100 self._prev_fast = fast_val self._prev_slow = slow_val return if self.take_profit_points > 0 and close <= self._entry_price - self.take_profit_points * step: self.BuyMarket() self._entry_price = 0.0 self._cooldown = 100 self._prev_fast = fast_val self._prev_slow = slow_val return if self._prev_fast <= self._prev_slow and fast_val > slow_val and self.Position <= 0: if self.Position < 0: self.BuyMarket() self.BuyMarket() self._entry_price = close self._cooldown = 100 elif self._prev_fast >= self._prev_slow and fast_val < slow_val and self.Position >= 0: if self.Position > 0: self.SellMarket() self.SellMarket() self._entry_price = close self._cooldown = 100 self._prev_fast = fast_val self._prev_slow = slow_val def CreateClone(self): return day_trading_trend_pullback_strategy()