Strategieparameter

Für Strategiekonfiguration und -optimierung stellt StockSharp die spezielle Klasse StrategyParam<T> bereit. Strategieparameter ermöglichen es, Einstellungen eines Handelsalgorithmus zu ändern, ohne den Code anzupassen. Das ist besonders praktisch beim Wechsel zwischen Test- und Live-Handelsmodus. Außerdem werden diese Parameter während der Optimierung verwendet, um Werte automatisch zu durchlaufen und optimale Strategieeinstellungen zu finden.

Im Gegensatz zu normalen C#-Eigenschaften werden mit dieser Klasse erstellte Parameter automatisch in visuellen Einstellungen angezeigt, beispielsweise im Designer, und können für die Strategieoptimierung verwendet werden.

Erstellen von Strategieparametern

Parameter werden im Strategiekonstruktor mit der Methode Strategy.Param erstellt:

public class SmaStrategy : Strategy
{
	private readonly StrategyParam<int> _longSmaLength;

	public int LongSmaLength
	{
		get => _longSmaLength.Value;
		set => _longSmaLength.Value = value;
	}

	public SmaStrategy()
	{
		_longSmaLength = Param(nameof(LongSmaLength), 80)
							.SetGreaterThanZero()
							.SetDisplay("Länge der langen SMA", string.Empty, "Grundeinstellungen");
	}
}

In diesem Beispiel wird ein Parameter LongSmaLength mit dem Anfangswert 80 erstellt, ein Validator gesetzt, der sicherstellt, dass der Wert größer als null ist, und Anzeigeeinstellungen für die Benutzeroberfläche werden konfiguriert.

Methoden zur Parameterkonfiguration

Die Klasse StrategyParam<T> stellt mehrere Methoden zur Parameterkonfiguration bereit:

SetDisplay

Die Methode StrategyParam<T>.SetDisplay legt Anzeigename, Beschreibung und Kategorie des Parameters fest:

_longSmaLength = Param(nameof(LongSmaLength), 80)
					.SetDisplay("Länge der langen SMA", "Periode des langen gleitenden Durchschnitts", "Grundeinstellungen");

SetValidator

Die Methode StrategyParam<T>.SetValidator legt einen Validator zur Prüfung des Parameterwerts fest. StockSharp stellt eine Reihe vordefinierter Validatoren bereit, die für die häufigsten Aufgaben verwendet werden können:

// Prüfen, dass die Zahl größer als null ist
_longSmaLength = Param(nameof(LongSmaLength), 80)
					.SetValidator(new IntGreaterThanZeroAttribute());

// Prüfen, dass die Zahl nicht negativ ist
_volume = Param(nameof(Volume), 1)
			.SetValidator(new DecimalNotNegativeAttribute());

// Wertebereich prüfen
_percentage = Param(nameof(Percentage), 50)
				.SetValidator(new RangeAttribute(0, 100));

// Pflichtwert prüfen
_security = Param<Security>(nameof(Security))
				.SetValidator(new RequiredAttribute());

Zur Vereinfachung verfügt StrategyParam<T> über integrierte Methoden für die häufigsten Validatoren:

// Prüfen, dass die Zahl größer als null ist
_longSmaLength = Param(nameof(LongSmaLength), 80).SetGreaterThanZero();

// Prüfen, dass die Zahl nicht negativ ist
_volume = Param(nameof(Volume), 1).SetNotNegative();

// Prüfen, dass der Wert NULL oder nicht negativ ist
_interval = Param<TimeSpan?>(nameof(Interval)).SetNullOrNotNegative();

// Wertebereich festlegen
_percentage = Param(nameof(Percentage), 50).SetRange(0, 100);

Wenn die integrierten Validatoren nicht ausreichen, können Sie eigene erstellen, indem Sie von ValidationAttribute erben:

public class EvenNumberAttribute : ValidationAttribute
{
	public EvenNumberAttribute()
		: base("Der Wert muss eine gerade Zahl sein.")
	{
	}

	public override bool IsValid(object value)
	{
		if (value is int intValue)
			return intValue % 2 == 0;

		return false;
	}
}

// Benutzerdefinierten Validator verwenden
_barCount = Param(nameof(BarCount), 10)
				.SetValidator(new EvenNumberAttribute());

SetHidden

Die Methode StrategyParam<T>.SetHidden blendet den Parameter im Eigenschaftseditor aus:

_systemParam = Param(nameof(SystemParam), "value")
				.SetHidden(true);

SetBasic

Die Methode StrategyParam<T>.SetBasic markiert den Parameter als Basisparameter. Dies beeinflusst seine Anzeige in der Benutzeroberfläche. Basisparameter werden im vereinfachten Modus des Eigenschaftseditors angezeigt:

_longSmaLength = Param(nameof(LongSmaLength), 80)
					.SetBasic(true);

Strategie Basis- und erweiterte Parameter

SetReadOnly

Die Methode StrategyParam<T>.SetReadOnly macht den Parameter schreibgeschützt:

_calculatedParam = Param(nameof(CalculatedParam), 0)
					.SetReadOnly(true);

SetCanOptimize und SetOptimize

Die Methoden StrategyParam<T>.SetCanOptimize und StrategyParam<T>.SetOptimize geben an, ob der Parameter für die Optimierung verwendet werden kann, und legen den Wertebereich für die Optimierung fest:

_longSmaLength = Param(nameof(LongSmaLength), 80)
					.SetCanOptimize(true)
					.SetOptimize(10, 200, 10);

Im obigen Beispiel wird der Parameter im Bereich von 10 bis 200 mit einer Schrittweite von 10 optimiert.

Verwendung von Parametern in der Strategie

Strategieparameter werden wie normale Eigenschaften verwendet:

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

	_shortSma = new SimpleMovingAverage { Length = ShortSmaLength };
	_longSma = new SimpleMovingAverage { Length = LongSmaLength };

	// ...
}

Speichern und Laden von Parametern

Parameterwerte werden in der Basisklasse Strategy automatisch gespeichert und geladen. Wenn Sie die Methoden Strategy.Save und Strategy.Load überschreiben, müssen Sie die Methoden der Basisklasse aufrufen:

public override void Save(SettingsStorage settings)
{
	base.Save(settings);

	// Zusätzliche Speicherlogik...
}

public override void Load(SettingsStorage settings)
{
	base.Load(settings);

	// Zusätzliche Ladelogik...
}

Beispiel: Strategie mit mehreren Parametern

Unten sehen Sie ein Beispiel für eine Strategie mit mehreren Parametern:

public class SmaStrategy : Strategy
{
	private readonly StrategyParam<DataType> _series;
	private readonly StrategyParam<int> _longSmaLength;
	private readonly StrategyParam<int> _shortSmaLength;

	public DataType Serie
	{
		get => _series.Value;
		set => _series.Value = value;
	}

	public int LongSmaLength
	{
		get => _longSmaLength.Value;
		set => _longSmaLength.Value = value;
	}

	public int ShortSmaLength
	{
		get => _shortSmaLength.Value;
		set => _shortSmaLength.Value = value;
	}

	public SmaStrategy()
	{
		base.Name = "SMA strategy";

		Param("TypeId", GetType().GetTypeName(false)).SetHidden();
		_longSmaLength = Param(nameof(LongSmaLength), 80)
							.SetGreaterThanZero()
							.SetDisplay("Länge der langen SMA", string.Empty, "Grundeinstellungen")
							.SetCanOptimize(true)
							.SetOptimize(20, 200, 10);

		_shortSmaLength = Param(nameof(ShortSmaLength), 30)
							.SetGreaterThanZero()
							.SetDisplay("Länge der kurzen SMA", string.Empty, "Grundeinstellungen")
							.SetCanOptimize(true)
							.SetOptimize(5, 50, 5);

		_series = Param(nameof(Serie), DataType.TimeFrame(TimeSpan.FromMinutes(15)))
					.SetDisplay("Serie", string.Empty, "Grundeinstellungen");
	}

	// ...
}

In diesem Beispiel wurde eine Strategie auf Basis der Kreuzung zweier gleitender Durchschnitte mit drei konfigurierbaren Parametern erstellt:

Serie - Datentyp und Zeitrahmen
LongSmaLength - Periode des langen gleitenden Durchschnitts
ShortSmaLength - Periode des kurzen gleitenden Durchschnitts

Für die beiden numerischen Parameter wurden Optimierungsfunktionen mit festgelegten Bereichen konfiguriert.

Siehe auch

Speichern und Laden von Einstellungen