Deutsch DE
Auf GitHub ansehen

Stop-Loss-Take-Profit-Strategie

Dieser Port repliziert den MetaTrader-Expertenberater «Stop Loss Take Profit». Die Strategie wirft eine Münze, wenn das Konto flat ist, und öffnet eine Market-Order in der gewählten Richtung. Jede Position erhält sofort pip-basierte Stop-Loss- und Take-Profit-Orders. Wenn der Stop ausgelöst wird, verdoppelt der nächste Trade seine Größe (begrenzt durch die Volumenlimits des Wertpapiers). Ein Take-Profit setzt das Volumen auf den Anfangsbetrag zurück. Das Verhalten spiegelt die ursprüngliche Martingal-Positionsgrößenbestimmung wider und nutzt dabei StockSharp's High-Level-API.

Handelslogik

  • Marktdaten: Verwendet den CandleType-Parameter (Standard: 1-Minuten-Zeitrahmen), um Entscheidungspunkte zu steuern.
  • Einstiegsregeln:
    • Wenn Position == 0 und keine Einstiegsorder ausstehend ist, generiert die Strategie ein pseudozufälliges Boolean.
    • true öffnet eine Long-Position mit BuyMarket(volume); false öffnet eine Short mit SellMarket(volume).
  • Ausstiegsregeln:
    • Schutz-Stop-Loss- und Take-Profit-Orders werden platziert, sobald der Einstiegsfill empfangen wird.
    • Ein Stop-Ausstieg verdoppelt die Größe für den nächsten Trade, während ein Take-Profit diese zurücksetzt.
    • Wenn Stop- oder Take-Profit-Abstand auf 0 gesetzt ist, wird die jeweilige Schutzorder übersprungen.
  • Money-Management:
    • InitialVolume definiert die Basisauftragsgröße.
    • Nach einem verlorenen Trade wird die Größe verdoppelt, aber auf Security.MaxVolume begrenzt, wenn dieser Wert verfügbar ist.
    • Volumen wird zum VolumeStep, MinVolume und MaxVolume des Instruments normalisiert, damit Orders gültig bleiben.
  • Pip-Verarbeitung:
    • Standardmäßig leitet die Strategie einen Pip aus PriceStep und Decimals des Instruments ab (5-stellige FX-Symbole entsprechen 0.0001).
    • Setzen Sie PipSize auf einen positiven Wert, um die automatische Pip-Größenerkennung zu überschreiben.

Parameter

Name Standard Beschreibung
CandleType 1-Minuten-Kerzen Zeitrahmen für Münzwürfe und Einstiege.
StopLossPips 1 Stop-Loss-Abstand in Pips. 0 deaktiviert den Stop.
TakeProfitPips 1 Take-Profit-Abstand in Pips. 0 deaktiviert den Take-Profit.
InitialVolume 0.01 Start-Handelsvolumen. Nach Stop-Loss-Ereignissen verdoppelt, nach Gewinnen zurückgesetzt.
PipSize 0 (auto) Optionale Pip-Größenüberschreibung in absoluten Preiseinheiten.

Nutzungshinweise

  • Funktioniert auf der Long- und Short-Seite und ist bewusst richtungsneutral.
  • Schutzorders werden storniert, sobald die Position geschlossen wird, um veraltete Orders zu vermeiden.
  • Der Zufallsgenerator wird mit Environment.TickCount geseeded, was bedeutet, dass jede Session unterschiedliche Trade-Sequenzen produziert.
  • Geeignet zur Demonstration von Risiko-Layering und Martingal-Verhalten statt für Produktions-Trading ohne weitere Risikokontrollen.
using System;
using System.Collections.Generic;

using Ecng.Common;

using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Random direction strategy with pip-based stop loss and take profit that doubles the volume after losses.
/// </summary>
public class StopLossTakeProfitStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<decimal> _stopLossDistance;
	private readonly StrategyParam<decimal> _takeProfitDistance;
	private readonly StrategyParam<decimal> _initialVolume;

	private decimal _currentVolume;
	private decimal _entryPrice;
	private int _tradeCount;

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public decimal StopLossDistance
	{
		get => _stopLossDistance.Value;
		set => _stopLossDistance.Value = value;
	}

	public decimal TakeProfitDistance
	{
		get => _takeProfitDistance.Value;
		set => _takeProfitDistance.Value = value;
	}

	public decimal InitialVolume
	{
		get => _initialVolume.Value;
		set => _initialVolume.Value = value;
	}

	public StopLossTakeProfitStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe for evaluating entries", "General");

		_stopLossDistance = Param(nameof(StopLossDistance), 5m)
			.SetDisplay("Stop Loss Distance", "Stop loss distance in price units", "Risk");

		_takeProfitDistance = Param(nameof(TakeProfitDistance), 5m)
			.SetDisplay("Take Profit Distance", "Take profit distance in price units", "Risk");

		_initialVolume = Param(nameof(InitialVolume), 1m)
			.SetGreaterThanZero()
			.SetDisplay("Initial Volume", "Starting order volume", "Risk");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_currentVolume = 0;
		_entryPrice = 0;
		_tradeCount = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_currentVolume = InitialVolume;
		_entryPrice = 0m;

		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(ProcessCandle).Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle)
	{
		if (candle.State != CandleStates.Finished)
			return;

		// Check SL/TP for open position
		if (Position != 0 && _entryPrice > 0)
		{
			if (Position > 0)
			{
				var hitStop = StopLossDistance > 0 && candle.LowPrice <= _entryPrice - StopLossDistance;
				var hitTake = TakeProfitDistance > 0 && candle.HighPrice >= _entryPrice + TakeProfitDistance;

				if (hitStop)
				{
					SellMarket();
					HandleStopLoss();
					return;
				}

				if (hitTake)
				{
					SellMarket();
					HandleTakeProfit();
					return;
				}
			}
			else if (Position < 0)
			{
				var hitStop = StopLossDistance > 0 && candle.HighPrice >= _entryPrice + StopLossDistance;
				var hitTake = TakeProfitDistance > 0 && candle.LowPrice <= _entryPrice - TakeProfitDistance;

				if (hitStop)
				{
					BuyMarket();
					HandleStopLoss();
					return;
				}

				if (hitTake)
				{
					BuyMarket();
					HandleTakeProfit();
					return;
				}
			}
		}

		// Enter new position when flat
		if (Position == 0)
		{
			_tradeCount++;

			// Use candle direction as a deterministic signal
			if (candle.ClosePrice < candle.OpenPrice)
			{
				SellMarket();
			}
			else
			{
				BuyMarket();
			}

			_entryPrice = candle.ClosePrice;
		}
	}

	private void HandleStopLoss()
	{
		// Double volume on loss (martingale)
		_currentVolume *= 2m;

		var maxVol = Security?.MaxVolume;
		if (maxVol.HasValue && maxVol.Value > 0 && _currentVolume > maxVol.Value)
			_currentVolume = maxVol.Value;

		Volume = _currentVolume;
		_entryPrice = 0m;
	}

	private void HandleTakeProfit()
	{
		// Reset volume on profit
		_currentVolume = InitialVolume;
		Volume = _currentVolume;
		_entryPrice = 0m;
	}
}