Deutsch DE
Auf GitHub ansehen

Auto Adjusting-Strategie

AutoAdjustingStrategy repliziert den MetaTrader-Experten Aouto Adjusting1 mit der High-Level-API von StockSharp. Die Portierung behält den ursprünglichen Multi-Timeframe-Momentum-Filter, die monatliche MACD-Trendbestätigung und einen Drei-EMA-Stapel zur Erkennung von trendkonformen Rücksetzern. Stops und Ziele werden aus aktuellen Schwingungs-Extremen projiziert und bei jeder abgeschlossenen Kerze automatisch angepasst.

Kernlogik

  1. Trendstruktur – drei exponentielle gleitende Durchschnitte auf dem Handelszeitrahmen (6, 14, 26) müssen ausgerichtet sein (EMA6 < EMA14 < EMA26 für Longs, umgekehrt für Shorts). Die vorherige Kerze muss die mittlere EMA berühren, während die Kerze davor ein höheres Tief / niedrigeres Hoch bildet, um einen Rücksetzer zu bestätigen.
  2. Momentum-Bestätigung – Momentum auf dem höheren Zeitrahmen (abgebildet vom Handelszeitrahmen, z.B. H1 → D1) muss bei mindestens einer der letzten drei abgeschlossenen Balken um mindestens MomentumBuyThreshold / MomentumSellThreshold von 100 abweichen.
  3. Makro-Filter – ein monatliches MACD(12, 26, 9)-Signal stellt sicher, dass Trades mit dem dominanten Trend ausgerichtet sind (MACD > Signal für Käufe, < für Verkäufe).
  4. Ausführung – Market-Orders werden gesendet, sobald alle Filter übereinstimmen und keine entgegengesetzte Exposition vorhanden ist. Entgegengesetzte Positionen werden vor dem Einstieg in die neue Richtung abgebaut.
  5. Schutz – Stop-Loss-Niveaus werden um einen konfigurierbaren Pip-Puffer über das niedrigste Tief / höchste Hoch der letzten CandlesBack Balken platziert. Take-Profit-Abstände werden mit RewardRatio skaliert. Sowohl Stop als auch Ziel werden bei jedem Kerzenschluss neu aktiviert, während die Position aktiv ist.

Risiko und Positionsgröße

Die Strategie spiegelt die ursprüngliche Risikoparametrisierung wider:

  • RiskPercent berechnet eine adaptive Positionsgröße, wenn Portfoliowert und Preisschritt-Metadaten verfügbar sind. Der Algorithmus teilt den erlaubten Geldverlust durch den Verlust pro Einheit, der durch die aktuelle Stop-Distanz impliziert wird.
  • Wenn risikobasiertes Sizing nicht bewertet werden kann (z.B. fehlende Portfolio-Statistiken), fällt die Engine auf den festen TradeVolume-Parameter zurück.

Parameter

Name Typ Standard Beschreibung
CandleType DataType TimeFrame(H1) Handelszeitrahmen für den EMA-Stapel.
MomentumCandleType DataType Abgeleitet von CandleType Höherer Zeitrahmen für den Momentum-Indikator (H1→D1, H4→W1, usw.).
MacroMacdCandleType DataType TimeFrame(30 days) Zeitrahmen für die Makro-MACD-Bestätigung (standardmäßig monatlich).
PadAmount decimal 3 Extra Pips über Schwingungs-Extreme bei der Stop-Berechnung.
RiskPercent decimal 0.1 Prozent des Portfolio-Eigenkapitals pro Trade riskiert.
RewardRatio decimal 2 Multiplikator für die Stop-Distanz zur Take-Profit-Platzierung.
CandlesBack int 3 Anzahl der Kerzen für die Schwingungs-Hoch/Tief-Erkennung.
MomentumBuyThreshold decimal 0.3 Mindest-Momentum-Abweichung für Long-Einstiege.
MomentumSellThreshold decimal 0.3 Mindest-Momentum-Abweichung für Short-Einstiege.
TradeVolume decimal 1 Fallback-Losgröße wenn risikobasiertes Sizing nicht verfügbar.

Diagramme und Visualisierung

  • Den Handelszeitrahmen abonnieren und die drei EMAs einzeichnen, um Rücksetzer zu beobachten.
  • Die Momentum-Serie im Panel des höheren Zeitrahmens verfolgen, um Energie-Schwellenwerte zu bestätigen.
  • MACD-Werte des Makro-Zeitrahmens überwachen, um den Trendfilter zu validieren.

Hinweise

  • Das automatische Zeitrahmen-Mapping entspricht dem MQL-Experten: M1→M15, M5→M30, M15→H1, M30→H4, H1→D1, H4→W1, D1→MN1. Andere Zeitrahmen behalten ihren ursprünglichen Wert.
  • Die Strategie vermeidet GetValue-Aufrufe auf Indikatoren, indem sie die jüngsten Werte innerhalb der Strategie speichert und über die Bind-Callbacks weiterleitet.
  • Das Trailing-Verhalten spiegelt den ursprünglichen EA wider, indem die Schutzniveaus bei jedem Kerzenschluss neu berechnet werden.
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 AutoAdjustingStrategy : 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 AutoAdjustingStrategy()
	{
		_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;
	}
}