Technischen Indikator in cTrader erstellen

Dieser Artikel beschreibt die Schritte zum Erstellen benutzerdefinierter technischer Indikatoren, einschließlich Tools für algorithmischen Handel oder manuelle Aktionen in cTrader.

Klicken Sie auf der Registerkarte Indicators der Algo-App auf die Schaltfläche New, um den Assistenten zur Algorithmuserstellung zu öffnen.

WindowsMac

Geben Sie einen Namen für Ihren Indikator ein und wählen Sie dann eine Programmiersprache zwischen C# und Python.

WindowsMac

Wählen Sie eine Erstellungsmethode aus:

• Von Grund auf neu – der neue Indikator enthält nur eine Basisvorlage.

• Mit einer Vorlage – Sie können einen vorgefertigten Algorithmus aus einer Liste von Python#- oder C#-Vorlagen auswählen, die eine breite Palette von Indikatortypen, technischen Analysetools und mehr abdecken.

WindowsMac

Nachdem Sie auf Erstellen geklickt haben, öffnet sich der Code-Editor und Sie können mit der Bearbeitung des Indikator-Codes beginnen.

WindowsMac

Code bearbeiten

Abhängig von Ihrer Erstellungsmethode sollte das Indikatorcode-Beispiel eines oder mehrere der folgenden Elemente enthalten:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

[Indicator(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
public class SimpleIndicator : Indicator
{
    [Parameter(DefaultValue = "Hello world!")]
    public string Message { get; set; }

    [Output("Main")]
    public IndicatorDataSeries Result { get; set; }

    protected override void Initialize()
    {
    // Called once when the indicator is launched
    // Initialise variables, nested indicators or series

        Print(Message);
    }

    public override void Calculate(int index)
    {
    // Called automatically on each historical bar
    // Also called in real-time on each tick
    // Place the indicator formula and logic here
    }

    // === Custom Methods ===
    // Add helper methods below to structure your indicator logic

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class SimpleIndicator:
    def initialize(self):
        # Called once when the indicator is launched
        # Initialise variables, nested indicators or series
        api.Print(api.Message)

    def calculate(self, index):
        # Called automatically on each historical bar
        # Also called in real-time on each tick
        # Place the indicator formula and logic here
        api.Result[index] = 100 # Example calculation

    # === Custom Methods ===
    # Add helper methods below to structure your indicator logic

Speichern und erstellen

WindowsMac

Speichern Sie Ihren Code, indem Sie oben im Code-Editor auf den Button Speichern klicken oder die Tastenkombination Ctrl+S verwenden.

Bevor Sie Ihren cBot verwenden können, müssen Sie seinen Code validieren, indem Sie das cBot-Projekt erstellen. Klicken Sie oben im Code-Editor auf den Button Erstellen oder drücken Sie Ctrl+B.

Speichern Sie Ihren Code, indem Sie oben im Code-Editor auf das Symbol Speichern klicken oder die Tastenkombination Cmd+S verwenden.

Bevor Sie Ihren cBot verwenden können, müssen Sie seinen Code validieren, indem Sie das cBot-Projekt erstellen. Klicken Sie oben im Code-Editor auf das Symbol Erstellen oder drücken Sie Cmd+B.

Wenn die Erstellung erfolgreich ist, sehen Sie eine Bestätigungsmeldung in Erstellungsergebnis. Wenn die Erstellung fehlschlägt, wird stattdessen eine Zusammenfassung aller aufgetretenen Fehler angezeigt.

Wenn es seit der letzten Erstellung Änderungen am Code gibt, erscheint ein Sternchen neben dem Symbol Erstellen. In diesem Fall sollten Sie den Indikator erneut erstellen, bevor Sie eine Instanz davon zu einem Chart hinzufügen.

Um den Indikator auf einem Chart zu verwenden oder anzuzeigen, fügen Sie eine Instanz davon hinzu, oder Sie können den Indikator-Code weiter modifizieren, wie in den Abschnitten erläutert.

NaN-Arithmetik verwenden

Indikatoren führen Berechnungen durch, um bestimmte visuelle Darstellungen auszugeben, und es ist wichtig, dass Ihr Code Grenzfälle und Randbedingungen während dieser Berechnungen korrekt behandelt.

Betrachten Sie den folgenden Ausschnitt aus einem Indikator, der einen detrendierten Preisoszillator ausgibt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

private MovingAverage movingAverage;

protected override void Initialize()
{
    movingAverage = Indicators.SimpleMovingAverage(Source, Periods);
}

public override void Calculate(int index)
{
    Result[index] = Source[index] - movingAverage.Result[index - Periods / 2 - 1];
}

Der obige Code definiert allgemeine Berechnungsregeln, lässt jedoch Randbedingungen aus. Wenn beispielsweise Periods auf 10 gesetzt ist und index in den Bereich 0–9 fällt, gibt die Berechnung NaN (Not a Number) zurück. Dieses Problem tritt auf, weil der Indikator keine Werte für einen Balkenchart mit einem negativen Index berechnen kann.

Um das Problem zu beheben, können Sie eine Bedingung wie unten gezeigt hinzufügen:

1
2
3
4
5
6
7

public override void Calculate(int index)
{
    if (index >= Periods + Periods / 2 + 1)
    {
        Result[index] = Source[index] - movingAverage.Result[index - Periods / 2 - 1];
    }
}

Der Code für den einfachen gleitenden Durchschnitt selbst muss ebenfalls prüfen, dass index >= Periods. Wenn Sie einen verschachtelten Indikator verwenden, wie z. B. eine andere Art von gleitendem Durchschnitt, wird die Bedingung anders sein, um zusätzliche Berechnungen zu berücksichtigen.

Obwohl Sie explizite Randbedingungen definieren können, bietet C# eine bequeme Möglichkeit, diese Probleme durch NaN-Arithmetik zu vermeiden. Insbesondere unterstützt der Datentyp double NaN-Berechnungen vollständig. Zum Beispiel:

1
2
3
4
5

double result = double.NaN + 1.4; 
// result will be NaN

bool isNaN = double.IsNaN(result); 
// isNaN will be true

Wenn jedoch ein Operand in einer Berechnung NaN ist, wird das Ergebnis ebenfalls NaN sein. Da benutzerdefinierte cTrader-Indikatoren mit dem Typ DataSeries arbeiten, wird beim Versuch, auf ein DataSeries-Element mit einem negativen Index zuzugreifen, NaN zurückgegeben, und der Wert wird nicht auf dem Handelschart gezeichnet. Dieses Verhalten ermöglicht es dem Indikator, weiter zu arbeiten, ohne Ausnahmen auszulösen. In den meisten Fällen können Sie Randbedingungen sicher ignorieren und sich nur auf die allgemeine Berechnungslogik konzentrieren.

Explizite Prüfungen hinzufügen

Während NaN-Arithmetik die Behandlung von Randbedingungen vereinfacht, erfordern einige Fälle dennoch explizite NaN-Prüfungen. Rekursive Indikatoren sind ein häufiges Beispiel. Ein rekursiver Indikator berechnet seinen aktuellen Wert basierend auf dem zuvor berechneten Wert.

Betrachten Sie die folgende Implementierung eines Exponential Moving Average:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public override void Calculate(int index)
{
    var previousValue = Result[index - 1];

    if (double.IsNaN(previousValue))
    {
        Result[index] = Source[index];
    }
    else
    {
        Result[index] = Source[index] * _exp + previousValue * (1 - _exp);
    }
}

Wenn der Indikator die erste Periode berechnet, muss der Anfangswert explizit auf einen Nicht-NaN-Typ gesetzt werden. Andernfalls geben alle nachfolgenden Berechnungen NaN zurück, wodurch der Indikator unbrauchbar wird.

Im obigen Code wird dies mit der Methode double.IsNaN(previousValue) behandelt. Der Operator == kann für diese Prüfung nicht verwendet werden (previousValue == double.NaN), da jeder Vergleich von NaN mit einem anderen Wert, einschließlich sich selbst, immer zu false ausgewertet wird.

Wenn Sie mit dem Indikator-Code zufrieden sind, erstellen Sie ihn und verwenden Sie ihn dann, indem Sie eine Instanz zu einem Chart hinzufügen.