Deutsch DE
Auf GitHub ansehen

Exp Cronex Chaikin-Strategie

Diese Strategie portiert den MetaTrader-Expert-Advisor Exp_CronexChaikin.mq5 auf die High-Level-API von StockSharp. Der ursprüngliche Roboter rekonstruiert den Chaikin-Oszillator aus Akkumulations-/Distributionswerten, glättet ihn zweimal mit Cronex-„XMA"-Filtern und handelt Kreuzungen zwischen der schnellen und langsamen Linie. Die StockSharp-Version reproduziert dieselbe Logik und macht jede Phase als konfigurierbare Parameter verfügbar.

Handelslogik

  1. Die konfigurierte Kerzenserie (CandleType) abonnieren.
  2. Die Akkumulations-/Distributionslinie (AD) für jede abgeschlossene Kerze mit dem ausgewählten VolumeSource (Tick- oder echtes Volumen) neu berechnen.
  3. Den Chaikin-Oszillator anwenden, indem die AD-Linie mit zwei gleitenden Durchschnitten (ChaikinFastPeriod, ChaikinSlowPeriod, ChaikinMethod) geglättet und ihre Differenz genommen wird.
  4. Den resultierenden Oszillator zweimal mit den Cronex-Filtern glätten, die durch SmoothingMethod, FastPeriod, SlowPeriod und Phase gesteuert werden. Diese beiden geglätteten Werte entsprechen den „schnellen" und „Signal"-Linien im ursprünglichen Indikator.
  5. SignalBar abgeschlossene Kerzen zurückblicken und beide Cronex-Linien auf dieser und der vorherigen Kerze vergleichen.
  6. Wenn die schnelle Linie über der langsamen liegt, schließt die Strategie optional Short-Positionen und, wenn BuyOpenEnabled true ist, öffnet eine Long-Position, wenn ein frisches Aufwärtskreuz auf der Lookback-Kerze erkannt wurde.
  7. Wenn die schnelle Linie unter der langsamen liegt, werden für Short-Trades die entgegengesetzten Aktionen ausgeführt, gesteuert durch SellOpenEnabled und BuyCloseEnabled.
  8. Wann immer eine neue Position geöffnet wird, werden Stop-Loss- und Take-Profit-Orders (in Punkten ausgedrückt) mit StopLoss und TakeProfit neu berechnet.

Es wird nur eine einzige Nettoposition gehalten. Wenn sich die Signalrichtung ändert, kombiniert die Strategie das Volumen, das zum Schließen der aktuellen Position erforderlich ist, mit der neuen Handelsgröße, um das Netting-Verhalten von MetaTrader nachzuahmen.

Indikatoren und Glättungsoptionen

  • Chaikin-Oszillator: Aufgebaut durch Anwenden des ausgewählten ChaikinMethod-Gleitdurchschnittstyps auf die Akkumulations-/Distributionslinie. Verfügbare Optionen umfassen einfache, exponentielle, geglättete und linear gewichtete Durchschnitte.
  • Cronex-Glätter: Der Parameter SmoothingMethod stellt die Cronex-XMA-Familie zur Verfügung (SMA, EMA, SMMA, LWMA, Jurik JJMA/JurX, Parabolic MA, T3, VIDYA, AMA). Der Parameter Phase beeinflusst Jurik-basierte Filter genau wie in der MQL-Implementierung.

Parameter

Parameter Beschreibung
CandleType Datentyp der Kerzen zur Berechnung des Indikators. Standard ist ein Vier-Stunden-Zeitrahmen.
ChaikinMethod Gleitdurchschnittstyp im Chaikin-Oszillator.
ChaikinFastPeriod / ChaikinSlowPeriod Schnelle und langsame Perioden für die Akkumulations-/Distributionslinie.
SmoothingMethod Cronex-Glättungsalgorithmus für die Chaikin-Oszillatorwerte.
FastPeriod / SlowPeriod Längen der schnellen und langsamen Cronex-Linien.
Phase Phasenparameter für Jurik-basierte Glätter (Bereich -100 bis +100).
VolumeSource Wählt Tick- oder echtes Volumen für die Akkumulations-/Distributionslinie.
SignalBar Anzahl der abgeschlossenen Balken zurück, die das Kreuzsignal enthalten müssen.
BuyOpenEnabled / SellOpenEnabled Long- oder Short-Trades aktivieren oder deaktivieren.
BuyCloseEnabled / SellCloseEnabled Schließen der entgegengesetzten Position bei inversem Signal erlauben.
TakeProfit / StopLoss Gewinnziel und schützende Stop-Distanzen in Instrumentenpunkten nach jedem Einstieg.
Volume Standard-StockSharp-Positionsgröße (entspricht der Lot-Größe im ursprünglichen Experten).

Unterschiede zur MQL-Version

  • Geldmanagement- und Slippage-Routinen aus TradeAlgorithms.mqh werden durch die integrierten Volume-, SetStopLoss- und SetTakeProfit-Helfer ersetzt.
  • Die StockSharp-Implementierung berechnet die AD-Linie nur bei abgeschlossenen Kerzen neu, was deterministisches Verhalten für Tests und Live-Trading sicherstellt.
  • Cronex-Glättungsoptionen basieren auf StockSharp-Indikatoren: Jurik-Filter werden durch JurikMovingAverage (mit Phasenkontrolle) unterstützt, während VIDYA und ParMA exponentielle Näherungen verwenden, die mit anderen Cronex-Konvertierungen konsistent sind.
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 ExpCronexChaikinStrategy : 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 ExpCronexChaikinStrategy()
	{
		_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;
	}
}