Deutsch DE
Auf GitHub ansehen

Open Close-Strategie

Übersicht

Open Close ist ein Port des MetaTrader 5-Expertenberaters Open Close.mq5 (Ticket 23090). Die Strategie beobachtet die Beziehung zwischen den Eröffnungs- und Schlusskursen der zwei jüngsten abgeschlossenen Kerzen. Es wird jeweils eine Position gehandelt: Wenn die neuere Kerze sich relativ zur vorherigen umkehrt, wird eingestiegen; wenn beide Kerzen in dieselbe Richtung zeigen, wird ausgestiegen. Die C#-Version reproduziert das originale adaptive Lot-Sizing, das die Exposition nach einer Verlustserie reduziert.

Strategielogik

Kerzenmuster-Filter

  • Die Strategie arbeitet ausschließlich mit abgeschlossenen Kerzen, die durch den konfigurierbaren CandleType-Parameter geliefert werden.
  • Sie hält ein rollendes Fenster der zwei letzten abgeschlossenen Kerzen (als previous und older bezeichnet).
  • Das Muster vergleicht sowohl Eröffnungs- als auch Schlusskurse dieser Kerzen:
    • Bullische Umkehr – previous.Open > older.Open und previous.Close < older.Close.
    • Bärische Umkehr – previous.Open < older.Open und previous.Close > older.Close.

Einstiegsregeln

  • Wenn keine Position offen ist und das bullische Umkehrmuster erscheint, sendet die Strategie eine Markt-Kauforder.
  • Wenn keine Position offen ist und das bärische Umkehrmuster erscheint, sendet sie eine Markt-Verkaufsorder.
  • Es ist nur eine Position erlaubt. Gegensignale werden ignoriert, bis der aktive Trade geschlossen ist.

Ausstiegsregeln

  • Wenn eine Long-Position gehalten wird, steigt die Strategie aus, wenn sich beide verfolgten Kerzen nach unten bewegen (previous.Open < older.Open und previous.Close < older.Close).
  • Wenn eine Short-Position gehalten wird, ist der Ausstiegstrigger symmetrisch (previous.Open > older.Open und previous.Close > older.Close).
  • Im originalen Berater gibt es keine Stop-Loss- oder Take-Profit-Orders, daher stützt sich der Port ausschließlich auf die Kerzenbeziehung zum Schließen von Trades.

Positionsgröße und Verlustserien-Handling

  • Das Ordervolumen wird primär durch MaximumRiskPercent bestimmt – der gewünschte Anteil des Portfoliowerts, der pro Trade investiert wird. Die Rohgröße ist Portfolio.CurrentValue × MaximumRiskPercent ÷ referencePrice unter Verwendung des letzten Schlusskurses als Preisersatz.
  • Wenn die Portfoliobewertung oder der Preis nicht verfügbar ist, dient der FallbackVolume-Parameter als sicherer Standardwert.
  • Nach jedem vollständig geschlossenen Trade wird der realisierte PnL gespeichert. Die aufeinanderfolgende Verlusserie wird über die letzten HistoryDays Tage gezählt.
    • Wenn die Serie größer als ein Trade ist, wird die nächste Ordergröße um volume × losses ÷ DecreaseFactor reduziert, was die MT5-Logik nachahmt.
  • Das endgültige Volumen respektiert den Volumen-Step des Instruments sowie minimale und maximale Volumengrenzen.

Zusätzliche Implementierungshinweise

  • Die Strategie reagiert nur auf CandleStates.Finished und stellt sicher, dass das Muster vollständige Marktdaten verwendet.
  • Einstiegs- und Ausstiegsprüfungen erfolgen beim Schlusskurs der neuesten Kerze. In MetaTrader wird die Order zur Eröffnung der nächsten Kerze gesendet; der Unterschied ist für höhere Zeitrahmen vernachlässigbar, sollte aber für sehr kurze Intervalle beachtet werden.
  • Portfolio-Kennzahlen in StockSharp approximieren die Kontoinformationen von MetaTrader. Passen Sie MaximumRiskPercent oder FallbackVolume an, wenn der Broker unterschiedliche Kontraktmultiplikatoren verwendet.

Parameter

Parameter Typ Standard Beschreibung
MaximumRiskPercent decimal 0.02 Anteil des Portfoliowerts für eine neue Position (0.02 = 2%).
DecreaseFactor decimal 3 Divisor für die Lotgröße nach aufeinanderfolgenden Verlust-Trades. Größere Werte mildern die Reduktion.
HistoryDays int 60 Anzahl der Kalendertage, die beim Zählen der aktuellen Verlustserie gescannt werden.
FallbackVolume decimal 0.1 Ordervolumen, wenn die risikobasierte Berechnung nicht durchgeführt werden kann.
CandleType DataType TimeFrame(15m) Kerzenserie, die Eröffnungs-/Schlusskurse für die Signalerstellung liefert.

Unterschiede zur MetaTrader-Version

  • Kontomargenchecks stützen sich auf StockSharp's Portfolio.CurrentValue; MetaTrader verwendete AccountFreeMargin. Das Verhalten entspricht der ursprünglichen Risikoregel nur wenn beide Plattformen ähnliche Bewertungen melden.
  • Der Trade-Verlauf wird aus den eigenen Ausführungen der Strategie gesammelt anstatt aus der terminweiten Geschichte. Stellen Sie sicher, dass die Strategie lange genug läuft, um Serienstatistiken zu akkumulieren.
  • Der Port behält das Einzelpositionsmodell (keine Pyramidisierung) bei und spiegelt die ursprüngliche Abwesenheit von Schutzorders wider. Fügen Sie bei Bedarf extern Stops für die Risikokontrolle hinzu.
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;

/// <summary>
/// Open Close strategy using EMA crossover.
/// Buys when fast EMA crosses above slow EMA, sells on reverse.
/// </summary>
public class OpenClose23090Strategy : 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 OpenClose23090Strategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 15).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator");
		_slowPeriod = Param(nameof(SlowPeriod), 60).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;
	}
}