Deutsch DE
Auf GitHub ansehen

e-TurboFx Momentum-Strategie

Überblick

Die e-TurboFx Momentum Strategy ist eine direkte Portierung des ursprünglichen MetaTrader 4 Expertenberaters „e-TurboFx“. Das System scannt die zuletzt fertiggestellten Kerzen und sucht nach Richtungsabschnitten, in denen sich die Kerzenkörper weiter ausdehnen. Aufeinanderfolgende bärische Kerzen mit wachsender Körpergröße signalisieren eine mögliche Kapitulation, die mit einem Long-Einstieg abgeschwächt werden kann, während aufeinanderfolgende bullische Kerzen mit expandierenden Körpern auf eine überzogene Rallye hinweisen, die möglicherweise leer verkauft wird. Die StockSharp-Implementierung hält die Logik ereignisgesteuert durch Kerzenabonnements und fügt automatisch optionalen Stop-Loss- und Take-Profit-Schutz hinzu.

Handelslogik

  1. Abonnieren Sie einen konfigurierbaren Kerzentyp (Zeitrahmen) und verarbeiten Sie nur fertige Kerzen.
  2. Verfolgen Sie zwei separate Sequenzen: eine für bärische Kerzen und eine für bullische Kerzen.
  3. Messen Sie für jede Kerze die absolute Körpergröße (|Close - Open|).
  4. Setzen Sie die Gegenrichtungssequenz zurück, sobald eine Kerze in die andere Richtung schließt.
  5. Innerhalb jeder Sequenz sind streng expandierende Körper erforderlich – jede neue Kerze muss einen größeren Körper haben als die vorherige. Jede Kontraktion startet den Sequenzzähler von 1 neu.
  6. Wenn die Anzahl der Kerzen in einer Sequenz DepthAnalysis erreicht, lösen Sie einen Markteintritt in die entgegengesetzte Richtung der letzten Sequenz aus (Kauf nach Abwärtstrends, Verkauf nach Aufwärtstrends).
  7. Sobald eine Position offen ist, pausieren Sie die Signalerkennung, bis die Strategie zu einer flachen Position zurückkehrt. Das integrierte StartProtection verwaltet optionale Stop-Loss- und Take-Profit-Abstände, ausgedrückt in Preisschritten (Ticks).

Dieses Verhalten reproduziert den MQL4-Algorithmus, bei dem der Fachberater die letzten N geschlossenen Kerzen überprüfte und bestätigte, dass alle Körper in die gleiche Richtung ausgerichtet waren und dass jeder Körper größer als der Körper der nächstälteren Kerze war.

Details zur Implementierung

  • Verwendet das High-Level-Kerzenabonnement API mit SubscribeCandles und Bind, um die Projektrichtlinien einzuhalten.
  • Behält nur Skalarfelder (_bearishSequence, _bullishSequence, _previousBearishBody, _previousBullishBody), um benutzerdefinierte Sammlungen zu vermeiden und sich auf den internen Status zwischen Ereignissen zu verlassen.
  • Ruft StartProtection nur einmal in OnStarted auf, um optionale Stop-Loss- und Take-Profit-Orders in Preisschritten zu konfigurieren. Ein Wert von 0 deaktiviert jede Schutzanordnung, genau wie der ursprüngliche Experte.
  • Bietet ausführliche englische Kommentare im Quellcode, einschließlich Erläuterungen zu Zurücksetzungen und Eintragsauslösern.
  • Zeichnet Kerzen und eigene Trades in einem Diagrammbereich, wenn es im Designer oder auf der Benutzeroberfläche ausgeführt wird, um das Debuggen zu erleichtern.

Parameter

Parameter Beschreibung Standard
DepthAnalysis Anzahl der aufeinanderfolgenden fertigen Kerzen, die in eine Richtung mit expandierenden Körpern erforderlich sind, bevor ein Handel eröffnet wird. 3
TakeProfitSteps Take-Profit-Distanz gemessen in Börsenpreisschritten (Ticks). Auf 0 setzen, um den Take-Profit zu deaktivieren. 120
StopLossSteps Stop-Loss-Distanz gemessen in Börsenkursschritten (Ticks). Auf 0 setzen, um den Stop-Loss zu deaktivieren. 70
TradeVolume Mit jeder Marktorder gesendetes Volumen. Wenn Sie diesen Parameter ändern, wird auch die Basis Strategy.Volume aktualisiert. 0.1
CandleType Für die Analyse abonnierter Kerzendatentyp (Zeitrahmen). 1 hour

Alle numerischen Parameter stellen Optimierungsmetadaten bereit, sodass die Strategie bei Bedarf mit StockSharp Optimierern optimiert werden kann.

Hinweise und Empfehlungen

  • Da die Strategie auf die Expansion des Kerzenkörpers reagiert, beeinflusst der gewählte Zeitrahmen die Signalfrequenz erheblich. Kürzere Intervalle führen zu mehr Trades, erfordern jedoch möglicherweise engere Schutzabstände.
  • Stellen Sie sicher, dass die verbundene Sicherheit einen gültigen PriceStep definiert. andernfalls können die stufenweisen Schutzabstände nicht in absolute Preise umgerechnet werden.
  • Testen Sie den Port im StockSharp-Designer vor der Live-Bereitstellung erneut, um zu überprüfen, wie Stopp und Ziel für das ausgewählte Instrument übersetzt werden.
  • Die Strategie behält jeweils eine einzelne offene Position bei. Nach jedem Beenden werden die Zähler zurückgesetzt und das Muster muss von Grund auf neu erstellt werden, um das ursprüngliche MQL4-Verhalten widerzuspiegeln.
using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Momentum reversal strategy that tracks consecutive candles with expanding bodies.
/// </summary>
public class ETurboFxMomentumStrategy : Strategy
{
	private readonly StrategyParam<int> _depthAnalysis;
	private readonly StrategyParam<decimal> _takeProfitSteps;
	private readonly StrategyParam<decimal> _stopLossSteps;
	private readonly StrategyParam<decimal> _tradeVolume;
	private readonly StrategyParam<DataType> _candleType;

	private int _bearishSequence;
	private int _bullishSequence;
	private decimal _previousBearishBody;
	private decimal _previousBullishBody;

	/// <summary>
	/// Number of recent candles analysed for momentum confirmation.
	/// </summary>
	public int DepthAnalysis
	{
		get => _depthAnalysis.Value;
		set => _depthAnalysis.Value = value;
	}

	/// <summary>
	/// Take profit distance measured in price steps (ticks).
	/// A value of zero disables the take profit order.
	/// </summary>
	public decimal TakeProfitSteps
	{
		get => _takeProfitSteps.Value;
		set => _takeProfitSteps.Value = value;
	}

	/// <summary>
	/// Stop loss distance measured in price steps (ticks).
	/// A value of zero disables the protective stop.
	/// </summary>
	public decimal StopLossSteps
	{
		get => _stopLossSteps.Value;
		set => _stopLossSteps.Value = value;
	}

	/// <summary>
	/// Volume used when sending market orders.
	/// </summary>
	public decimal TradeVolume
	{
		get => _tradeVolume.Value;
		set
		{
			_tradeVolume.Value = value;
			Volume = value;
		}
	}

	/// <summary>
	/// Candle type analysed by the strategy.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of the <see cref="ETurboFxMomentumStrategy" /> class.
	/// </summary>
	public ETurboFxMomentumStrategy()
	{
		_depthAnalysis = Param(nameof(DepthAnalysis), 3)
			.SetGreaterThanZero()
			.SetDisplay("Depth Analysis", "Number of finished candles used for pattern detection", "Trading Rules")
			
			.SetOptimize(2, 6, 1);

		_takeProfitSteps = Param(nameof(TakeProfitSteps), 120m)
			.SetNotNegative()
			.SetDisplay("Take Profit (steps)", "Take profit distance in price steps (ticks)", "Risk Management")
			
			.SetOptimize(60m, 180m, 20m);

		_stopLossSteps = Param(nameof(StopLossSteps), 70m)
			.SetNotNegative()
			.SetDisplay("Stop Loss (steps)", "Stop loss distance in price steps (ticks)", "Risk Management")
			
			.SetOptimize(40m, 120m, 10m);

		_tradeVolume = Param(nameof(TradeVolume), 0.1m)
			.SetGreaterThanZero()
			.SetDisplay("Trade Volume", "Order volume used for entries", "Trading Rules")
			
			.SetOptimize(0.1m, 0.5m, 0.1m);

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe of the candles analysed by the strategy", "Market Data");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		ResetState();
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		ResetState();
		Volume = TradeVolume;

		var takeProfitUnit = CreateStepUnit(TakeProfitSteps);
		var stopLossUnit = CreateStepUnit(StopLossSteps);

		if (takeProfitUnit != null || stopLossUnit != null)
		{
			// Configure protective orders once the strategy starts.
			StartProtection(
				takeProfit: takeProfitUnit,
				stopLoss: stopLossUnit,
				isStopTrailing: false,
				useMarketOrders: true);
		}

		var subscription = SubscribeCandles(CandleType);

		subscription
			.Bind(ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawOwnTrades(area);
		}
	}

	private Unit CreateStepUnit(decimal steps)
	{
		if (steps <= 0)
			return null;

		// Convert the user-friendly tick distance into a StockSharp Unit instance.
		return new Unit(steps, UnitTypes.Absolute);
	}

	private void ProcessCandle(ICandleMessage candle)
	{
		if (candle.State != CandleStates.Finished)
			return;

		// indicators formed check removed

		if (Position != 0)
		{
			// Do not look for new signals while a position is active.
			ResetState();
			return;
		}

		var bodySize = Math.Abs(candle.ClosePrice - candle.OpenPrice);

		// The original expert compared absolute bodies of the latest N closed candles.
		// Measuring the body here reproduces that behaviour candle by candle.

		if (candle.ClosePrice < candle.OpenPrice)
		{
			HandleBearishCandle(bodySize);
		}
		else if (candle.ClosePrice > candle.OpenPrice)
		{
			HandleBullishCandle(bodySize);
		}
		else
		{
			// Neutral candle breaks both sequences.
			ResetState();
		}
	}

	private void HandleBearishCandle(decimal bodySize)
	{
		// Bearish candles reset the bullish path and allow the downside streak to continue.
		ResetBullishSequence();

		if (bodySize <= 0)
		{
			ResetBearishSequence();
			return;
		}

		if (_bearishSequence == 0 || bodySize > _previousBearishBody)
		{
			// Body is larger than the previous bearish candle, extend the sequence.
			_bearishSequence++;
		}
		else
		{
			// Sequence restarts because body did not expand.
			_bearishSequence = 1;
		}

		_previousBearishBody = bodySize;

		if (_bearishSequence >= DepthAnalysis)
		{
			// Expanding bearish bodies suggest exhaustion that can trigger a long entry.
			BuyMarket();
			ResetBearishSequence();
		}
	}

	private void HandleBullishCandle(decimal bodySize)
	{
		// Bullish candles reset the bearish path and allow the upside streak to continue.
		ResetBearishSequence();

		if (bodySize <= 0)
		{
			ResetBullishSequence();
			return;
		}

		if (_bullishSequence == 0 || bodySize > _previousBullishBody)
		{
			// Body is larger than the previous bullish candle, extend the sequence.
			_bullishSequence++;
		}
		else
		{
			// Sequence restarts because body did not expand.
			_bullishSequence = 1;
		}

		_previousBullishBody = bodySize;

		if (_bullishSequence >= DepthAnalysis)
		{
			// Expanding bullish bodies suggest potential reversal to the downside.
			SellMarket();
			ResetBullishSequence();
		}
	}

	private void ResetBearishSequence()
	{
		_bearishSequence = 0;
		_previousBearishBody = 0m;
	}

	private void ResetBullishSequence()
	{
		_bullishSequence = 0;
		_previousBullishBody = 0m;
	}

	private void ResetState()
	{
		ResetBearishSequence();
		ResetBullishSequence();
	}
}