Deutsch DE
Auf GitHub ansehen

Neue Zufallsstrategie

Überblick

Die Neue Zufallsstrategie emuliert den ursprünglichen MetaTrader-Experten "New Random" und bietet drei verschiedene Einstiegs-Auswahlmodi. Sie öffnet immer nur eine einzige Position und wartet, bis die aktuelle Position geschlossen ist, bevor sie die nächste Orderrichtung generiert. Markteinstiege werden bei Top-of-Book-Updates (Level-1-Daten) ausgelöst und verwenden die besten Bid/Ask-Kurse als Ausführungsanker. Die Strategie berechnet automatisch Stop-Loss- und Take-Profit-Abstände in Pips und passt sich an 3- und 5-stellige Forex-Kurse genauso wie die MQL-Version an.

Einstiegsmodi

  1. Generator – Die nächste Richtung wird durch einen Pseudozufallsgenerator gewählt, der beim Strategiestart geseeded wird. Jede Gelegenheit ist ein unabhängiger Münzwurf zwischen Kauf und Verkauf.
  2. Kauf-Verkauf-Kauf – Positionen wechseln strikt zwischen Kauf und Verkauf. Die allererste Order ist ein Kauf, gefolgt von einem Verkauf, und so weiter.
  3. Verkauf-Kauf-Verkauf – Positionen wechseln strikt, beginnend mit einem Verkauf, gefolgt von einem Kauf, und wiederholen sich.

Parameter

  • Random Mode (Mode) – Wählt einen der drei oben beschriebenen Einstiegsmechanismen aus. Standardmäßig der Zufallsgenerator.
  • Minimal Lot Count (MinimalLotCount) – Multipliziert das minimale handelbare Volumen des Instruments. Ein Wert von 1 bedeutet, dass die Strategie genau Security.VolumeMin handelt, während höhere Werte die Ordergröße um ganze Vielfache skalieren.
  • Stop Loss (pips) (StopLossPips) – Abstand in Pips unterhalb/oberhalb des ausgeführten Preises, bei dem die Strategie die Position beendet. Auf 0 setzen, um den Stop-Loss zu deaktivieren.
  • Take Profit (pips) (TakeProfitPips) – Abstand in Pips, bei dem die Strategie Gewinne realisiert. Auf 0 setzen, um den Take-Profit zu deaktivieren.

Handelslogik

  1. Abonniert Level-1-Daten für das konfigurierte Wertpapier und speichert ständig die neuesten Bid-, Ask- und letzten Handelskurse.
  2. Wenn keine Position offen und keine Order ausstehend ist, wertet die Strategie den ausgewählten Modus aus, um die nächste Richtung zu bestimmen.
  3. Orders werden am Markt platziert, wobei der neueste beste Bid/Ask-Schnappschuss verwendet wird. Die Stop-Loss- und Take-Profit-Ziele werden sofort aus dem Einstiegskurs unter Verwendung der Pip-Distanzparameter berechnet.
  4. Es darf nur eine einzige Position gleichzeitig existieren. Nachfolgende Einstiege werden unterdrückt, bis die aktive Position vollständig geschlossen ist.

Positionsverwaltung

  • Long-Positionen werden vorzeitig beendet, wenn der aktuelle Kurs auf den Stop-Loss fällt oder darunter, oder auf den Take-Profit steigt oder darüber.
  • Short-Positionen werden beendet, wenn der aktuelle Kurs auf den Stop-Loss steigt oder darüber, oder auf den Take-Profit fällt oder darunter.
  • Kursvergleiche verwenden immer die frischesten Level-1-Informationen: den letzten Handelskurs, wenn verfügbar, andernfalls den besten Bid/Ask für die jeweilige Seite.
  • Nach dem Schließen eines Trades setzt die Strategie den internen Zustand zurück, wechselt optional die nächste Richtung (für Sequenzmodi) und wartet auf das nächste Kursupdate, bevor sie wieder einsteigt.

Hinweise

  • Die Strategie pyramidiert nie Positionen und hält das Verhalten für sequenzbasierte Modi deterministisch.
  • Der Zufallsmodus wird mit dem aktuellen Tick-Zähler geseeded, so dass jeder Lauf einen einzigartigen Orderstrom erzeugt.
  • Alle internen Kommentare und Protokolle sind auf Englisch, um den Repository-Richtlinien zu entsprechen.
using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Randomized entry strategy that mimics the MetaTrader "New Random" expert.
/// </summary>
public class NewRandomStrategy : Strategy
{
	/// <summary>
	/// Available direction selection modes.
	/// </summary>
	public enum RandomModes
	{
		/// <summary>Use a pseudo random generator for every entry decision.</summary>
		Generator,
		/// <summary>Alternate buy-sell-buy.</summary>
		BuySellBuy,
		/// <summary>Alternate sell-buy-sell.</summary>
		SellBuySell
	}

	private readonly StrategyParam<RandomModes> _mode;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;
	private readonly StrategyParam<DataType> _candleType;

	private Sides? _sequenceLastSide;
	private Sides? _positionSide;
	private decimal _entryPrice;
	private int _candleCount;

	/// <summary>Direction selection mode.</summary>
	public RandomModes Mode
	{
		get => _mode.Value;
		set => _mode.Value = value;
	}

	/// <summary>Stop loss in price steps.</summary>
	public int StopLossPoints
	{
		get => _stopLossPoints.Value;
		set => _stopLossPoints.Value = value;
	}

	/// <summary>Take profit in price steps.</summary>
	public int TakeProfitPoints
	{
		get => _takeProfitPoints.Value;
		set => _takeProfitPoints.Value = value;
	}

	/// <summary>Candle type.</summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public NewRandomStrategy()
	{
		_mode = Param(nameof(Mode), RandomModes.Generator)
			.SetDisplay("Random Mode", "Direction selection mode", "General");

		_stopLossPoints = Param(nameof(StopLossPoints), 5)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss (pts)", "Stop loss in price steps", "Risk");

		_takeProfitPoints = Param(nameof(TakeProfitPoints), 5)
			.SetGreaterThanZero()
			.SetDisplay("Take Profit (pts)", "Take profit in price steps", "Risk");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Candle timeframe", "General");
	}

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_sequenceLastSide = null;
		_positionSide = null;
		_entryPrice = 0m;
		_candleCount = 0;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_sequenceLastSide = Mode switch
		{
			RandomModes.BuySellBuy => Sides.Sell,
			RandomModes.SellBuySell => Sides.Buy,
			_ => null
		};

		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;

		_candleCount++;
		if (_candleCount < 3)
			return;

		var step = Security?.PriceStep ?? 1m;
		var stopDistance = StopLossPoints * step;
		var takeDistance = TakeProfitPoints * step;
		var price = candle.ClosePrice;

		// Check SL/TP for current position
		if (Position != 0 && _entryPrice > 0)
		{
			var hit = false;

			if (_positionSide == Sides.Buy)
			{
				if (stopDistance > 0 && candle.LowPrice <= _entryPrice - stopDistance)
					hit = true;
				if (takeDistance > 0 && candle.HighPrice >= _entryPrice + takeDistance)
					hit = true;
			}
			else if (_positionSide == Sides.Sell)
			{
				if (stopDistance > 0 && candle.HighPrice >= _entryPrice + stopDistance)
					hit = true;
				if (takeDistance > 0 && candle.LowPrice <= _entryPrice - takeDistance)
					hit = true;
			}

			if (hit)
			{
				if (Position > 0)
					SellMarket();
				else if (Position < 0)
					BuyMarket();

				_positionSide = null;
				_entryPrice = 0m;
			}
		}

		// If flat, open new random position
		if (Position == 0 && _positionSide == null)
		{
			var side = DetermineNextSide();

			if (side == Sides.Buy)
				BuyMarket();
			else
				SellMarket();

			_positionSide = side;
			_entryPrice = price;

			_sequenceLastSide = side;
		}
	}

	private Sides DetermineNextSide()
	{
		// All modes use deterministic alternating logic
		return _sequenceLastSide == Sides.Buy ? Sides.Sell : Sides.Buy;
	}
}