Deutsch DE
Auf GitHub ansehen

Breakdown Catcher-Strategie

Übersicht

Die Breakdown Catcher-Strategie ist ein Bar-für-Bar-Ausbruchssystem, das vom MetaTrader-Expert Advisor „Breakdown catcher" portiert wurde. Nach jeder abgeschlossenen Kerze platziert die Strategie virtuelle Ausbruchsniveaus oberhalb des vorherigen Hochs und unterhalb des vorherigen Tiefs (optional um einen Einzug verschoben). Wenn die nächste Kerze eines dieser Niveaus durchbricht, eröffnet die Strategie eine Position in der Ausbruchsrichtung und weist sofort Stop-Loss, Take-Profit und optionalen Trailing-Schutz in Pips zu.

Handelslogik

  1. Beim Schließen jeder Kerze werden das Hoch und das Tief der abgeschlossenen Kerze als Referenzbereich für die nächste Periode verwendet.
  2. Kauf-Ausbruchsniveau = vorheriges Hoch + Einzug (in Pips). Verkaufs-Ausbruchsniveau = vorheriges Tief − Einzug.
  3. Wenn die aktuelle Kerze das Kaufniveau durchbricht, während keine Position offen ist, eröffnet die Strategie eine Long-Position zum Markt, entfernt jeden Short-Kontext und speichert die Schutzniveaus.
  4. Wenn die aktuelle Kerze das Verkaufsniveau durchbricht, während flat, eröffnet die Strategie eine Short-Position zum Markt.
  5. Stop-Loss- und Take-Profit-Abstände werden von Pips in absolute Preise umgerechnet, indem der Instrument-Preisschritt und die klassische MetaTrader-Anpassung für 3/5-Dezimalstellen-Instrumente verwendet werden.
  6. Ein Trailing Stop kann den Schutzpreis straffen, nachdem sich der Trade um mindestens TrailingStop + TrailingStep Pips in die günstige Richtung bewegt hat. Der Trailing-Schritt imitiert die MetaTrader-Logik, bei der sich der Stop nur nach einer ausreichenden zusätzlichen Bewegung bewegt.
  7. Wenn beide Ausbruchsniveaus innerhalb derselben Kerze erreicht werden, überspringt die Strategie den Handel für diesen Balken, um eine mehrdeutige Ausführungsreihenfolge zu vermeiden.
  8. Ein Spread-Filter blockiert neue Einträge, wenn der aktuelle Bid-Ask-Spread die konfigurierte AllowedSpreadPoints-Zahl übersteigt.

Geldverwaltung

  • Die Strategie verwendet das Basis-Strategy.Volume für die Ordergröße. Beim Umkehren von Positionen wird das Volumen um den absoluten Wert der aktuellen Position erhöht, um einen vollständigen Flip zu gewährleisten.
  • Stop-Loss, Take-Profit und Trailing Stops werden intern durch Ausgabe von Market-Exit-Orders verwaltet, wenn Preisbereiche die Schutzniveaus umfassen.

Parameter

Parameter Beschreibung Standard
StopLossPips Stop-Loss-Abstand in Pips. 30
TakeProfitPips Take-Profit-Abstand in Pips. 90
TrailingStopPips Trailing-Stop-Abstand in Pips. Auf 0 setzen, um Trailing zu deaktivieren. 30
TrailingStepPips Zusätzlicher Fortschritt, der erforderlich ist, bevor sich der Trailing Stop bewegt. Muss positiv sein, wenn Trailing aktiviert ist. 5
IndentPips Zusätzlicher Versatz, der auf die Ausbruchsniveaus angewendet wird. 0
AllowedSpreadPoints Maximaler Spread gemessen in Rohpunkten (PriceStep-Einheiten). 5
CandleType Kerzenserie für die Ausbruchserkennung. 1h Zeitrahmen

Hinweise und Einschränkungen

  • Die Pip-Konvertierung folgt derselben Ziffernanpassung wie der Original-EA: Wenn das Instrument 3 oder 5 Dezimalstellen hat, entspricht ein Pip zehn Preisschritten.
  • Da die High-Level-API von StockSharp mit Kerzenereignissen arbeitet, kann die genaue Reihenfolge, in der beide Ausbruchsniveaus innerhalb einer einzelnen Kerze getroffen werden, nicht bestimmt werden; daher überspringt die Strategie solche Balken.
  • Schutzorders werden mit Market-Exits modelliert, sodass die Strategie eigenständig ist und nicht auf broker-seitige Stop-Orders angewiesen ist.
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 BreakdownCatcherStrategy : 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 BreakdownCatcherStrategy()
	{
		_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;
	}
}