Deutsch DE
Auf GitHub ansehen

Reversals-With-Pin-Bars-Strategie

Überblick

Diese Strategie ist ein C#-Port des MetaTrader-Expert-Advisors "Reversals With Pin Bars". Der ursprüngliche EA sucht nach Ablehnungskerzen mit langen Dochten (Pin Bars) und bestätigt sie mit einem Momentum-Filter, einer Trendprüfung über eine linear gewichtete gleitende Durchschnittslinie (LWMA) auf höherem Zeitrahmen und einem MACD-Richtungsfilter. Der Port behält diese Multi-Zeitrahmen-Struktur bei, nutzt ausschließlich StockSharp-Indikatoren und stellt die wichtigsten Risikosteuerungen als Parameter bereit.

Die Implementierung konzentriert sich auf die StockSharp-High-Level-API: Kerzen des primären Zeitrahmens treiben Einstiege an, während zusätzliche Abonnements Indikatoren höherer Zeitrahmen speisen. Risikomanagement wird in Pips ausgedrückt und unterstützt optionale Trailing-Stop- und Break-even-Automatisierung.

Einstiegslogik

  • Pin-Bar-Erkennung: Die vorherige abgeschlossene Kerze muss einen Docht haben, der mindestens 50% ihrer gesamten Spanne ausmacht.
    • Long-Setup: Der obere Schatten dominiert (entspricht der ursprünglichen "Hanging Man"-Prüfung).
    • Short-Setup: Der untere Schatten dominiert.
  • Trendfilter: Die schnelle LWMA (Länge = FastMaPeriod) muss im höheren Zeitrahmen über/unter der langsamen LWMA (SlowMaPeriod) liegen.
  • Momentum-Filter: Die absolute Entfernung des Momentum-Werts von 100 auf einer der letzten drei Bars des höheren Zeitrahmens muss MomentumThreshold überschreiten.
  • MACD-Filter: Die MACD-Hauptlinie muss im MACD-Zeitrahmen über/unter der Signallinie liegen.
  • Positionslimits: Die Netto-Exposure darf MaxTrades * Volume nicht überschreiten. Neue Trades verwenden die ausgerichtete Einstellung Volume.

Risikomanagement

  • Stop-Loss / Take-Profit: Feste Distanzen in Pips (StopLossPips, TakeProfitPips) vom Einstiegsschlusskurs.
  • Break-even: Wenn aktiviert, bewegt sich der Stop auf entry +/- BreakEvenOffsetPips, sobald der Preis um BreakEvenTriggerPips voranschreitet.
  • Trailing Stop: Wenn aktiviert, hält der Trail eine Distanz von TrailingStopPips zum letzten Schlusskurs.
  • Automatisches Glattstellen: Das Erreichen des berechneten Stops oder Ziels beendet die gesamte Position mit einer Marktorder.

Parameter

Parameter Beschreibung
TradeVolume Volumen für jeden neuen Einstieg, am Instrumentenschritt ausgerichtet.
MaxTrades Maximale Anzahl gleichgerichteter Einstiege (aggregiertes Volumenlimit).
StopLossPips Stop-Loss-Distanz in Pips.
TakeProfitPips Take-Profit-Distanz in Pips.
EnableTrailing / TrailingStopPips Aktiviert und konfiguriert die Trailing-Stop-Distanz.
EnableBreakEven / BreakEvenTriggerPips / BreakEvenOffsetPips Break-even-Aktivierung und Puffereinstellungen.
FastMaPeriod / SlowMaPeriod Längen der LWMAs des höheren Zeitrahmens.
MomentumPeriod / MomentumThreshold Momentum-Länge und minimale absolute Entfernung von 100.
MacdFastPeriod / MacdSlowPeriod / MacdSignalPeriod MACD-Konfiguration für den langfristigen Filter.
CandleType Primäre Kerzenserie für die Pin-Bar-Erkennung.
HigherCandleType Kerzenserie für LWMAs und Momentum.
MacdCandleType Kerzenserie für MACD.

Unterschiede zur MetaTrader-Version

  • Geldbasierte Take-Profit-, Trailing- und Equity-Stop-Optionen wurden ausgelassen; Risiko wird über Pips ausgedrückt.
  • Fraktallinien-Bestätigungen, die Chartobjekte erforderten, wurden durch indikatorbasierte Bedingungen ersetzt.
  • Alle Benachrichtigungen (Alerts, E-Mails, Push-Nachrichten) wurden entfernt; die StockSharp-Version konzentriert sich auf Handelslogik.

Nutzungshinweise

  1. Weisen Sie die Strategie einem Portfolio und Instrument zu und passen Sie dann die drei Kerzentypen an Ihr gewünschtes Multi-Zeitrahmen-Setup an.
  2. Stellen Sie sicher, dass der Preisschritt des Instruments der Pip-Definition entspricht (Standard-Fallback ist 0.0001).
  3. Starten Sie die Strategie; Stops, Ziele, Trailing und Break-even-Verwaltung erfolgen automatisch beim Kerzenschluss.
  4. Überwachen Sie die Ergebnisse; passen Sie Momentum- und LWMA-Längen an das Volatilitätsprofil des Instruments an.
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 ReversalsWithPinBarsStrategy : 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 ReversalsWithPinBarsStrategy()
	{
		_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;
	}
}