Deutsch DE
Auf GitHub ansehen

Triple-Top-Triple-Bottom-Strategie

Die Triple-Top-Triple-Bottom-Strategie ist ein Port des gleichnamigen MetaTrader-Expert-Advisors. Das ursprüngliche System kombiniert mehrere Bestätigungsebenen (Trendrichtung, Momentum-Stärke und einen MACD-Filter), bevor es in den Markt eintritt. Diese StockSharp-Implementierung behält dieselben Kernideen bei und stellt die wichtigen Schwellen als Strategieparameter bereit.

Kernlogik

  1. Trendfilter: Zwei linear gewichtete gleitende Durchschnitte (LWMA), berechnet auf dem typischen Preis (H+L+C)/3, definieren die Handelsrichtung. Die schnelle LWMA muss über der langsamen liegen, um Long-Trades zu erlauben, und darunter, um Short-Trades zu erlauben.
  2. Momentum-Bestätigung: Der eingebaute Momentum-Indikator mit konfigurierbarer Rückblicklänge muss innerhalb der letzten drei abgeschlossenen Kerzen mindestens um die benutzerdefinierte Schwelle vom neutralen Niveau 100 abweichen. Der EA verlangte dasselbe Verhalten durch Analyse vorheriger Momentum-Werte, und diese Validierung wird gespiegelt, um Einstiege in flachen Märkten zu vermeiden.
  3. MACD-Filter: Ein klassischer MACD-Signallinienfilter 12/26/9 verhindert Trades gegen einen starken Trend. Die Strategie kauft nur, wenn die MACD-Linie über der Signallinie liegt, und verkauft, wenn sie darunter liegt.
  4. Risikomanagement: Marktorders werden mit Stop-Loss- und Take-Profit-Zielen geschützt, die in absoluten Preiseinheiten gemessen werden. Die Parameter sind optional; null deaktiviert die jeweilige Order. Der Code schließt die Position außerdem, wenn der entgegengesetzte Risikoschwellenwert während der Kerzenverarbeitung erreicht wird.

Parameter

  • Entry Candle: DataType, der den Zeitrahmen der Arbeitskerzen definiert.
  • Fast LWMA / Slow LWMA: Längen der schnellen und langsamen Trendfilter.
  • Momentum Period / Momentum Threshold: Rückblick für den Momentum-Indikator und minimale Abweichung von 100, die eine Trade-Idee bestätigt.
  • Stop Loss / Take Profit: Schutzdistanzen in absoluten Preiseinheiten; sie werden außerdem über SetStopLoss und SetTakeProfit als native Schutzorders gesendet, sodass die Risikokontrolle auch greift, wenn die Strategiesitzung stoppt.

Unterschiede zur MQL-Version

  • Alle zusätzlichen Geldmanagement-Funktionen (Lot-Multiplikatoren, Equity-Schutz, Kerzen-Trailing, Break-even und manuelle Trendlinienprüfungen) wurden ausgelassen, weil die StockSharp-High-Level-API bereits Werkzeuge zur Positionsgrößenbestimmung bietet und die im ursprünglichen EA verwendeten grafischen Objekte MetaTrader-spezifisch sind.
  • Risikoschwellen werden in absoluten Preiseinheiten statt in Pips ausgedrückt. Dies hält die Implementierung brokerneutral; Benutzer können ihre gewünschte Pip-Distanz leicht umrechnen, indem sie die Pip-Größe des Brokers mit der gewünschten Pip-Anzahl multiplizieren.
  • Die Chartausgabe verwendet StockSharp-Bereiche für Preis-Kerzen, gleitende Durchschnitte, Momentum und MACD-Indikatoren.

Nutzungshinweise

  1. Binden Sie die Strategie an ein Instrument und konfigurieren Sie vor dem Start den gewünschten Kerzentyp.
  2. Passen Sie die Momentum-Schwelle und Stop-Distanzen an die Volatilität des Instruments an.
  3. Die Strategie handelt eine einzelne Nettoposition. Wenn ein Gegensignal erscheint, wird die aktuelle Exposure zuerst geschlossen, wodurch überlappende Trades verhindert werden.

Der Code ist vollständig auf Englisch kommentiert und folgt den im Repository bereitgestellten StockSharp-High-Level-API-Richtlinien.

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 TripleTopTripleBottomStrategy : 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 TripleTopTripleBottomStrategy()
	{
		_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;
	}
}