Zum Inhalt

Parallele Orderausführung in cTrader

Eines der Merkmale, die cTrader auszeichnen, ist die Möglichkeit, sowohl synchrone als auch asynchrone Programmierung zur Ausführung Ihrer Orders zu verwenden. Sie können synchrone Programmierung verwenden, um Strategien zu implementieren, die auf die Ergebnisse der Orderausführung warten müssen, bevor sie fortfahren; alternativ wird asynchrone Programmierung am besten verwendet, wenn Sie eine Hochgeschwindigkeitsstrategie erstellen, die mehrere Orders gleichzeitig übermitteln kann.

In diesem Video und dem dazugehörigen Artikel erklären wir den Unterschied zwischen synchroner und asynchroner Ausführung und zeigen Ihnen, wie Sie beide Ansätze zum Übermitteln neuer Orders verwenden können.

Synchrone vs. asynchrone Orderausführung

Grundlegende Abläufe

Die synchrone Orderausführung lässt sich anhand eines einfachen Diagramms erklären. Beim synchronen Übermitteln neuer Orders muss ein cBot warten, bis eine Order ausgeführt wurde, bevor er weiteren Anweisungen folgt. Mit anderen Worten: cTrader sendet eine Order an den Server, wartet auf die Antwort und beginnt erst dann mit der Ausführung der nächsten Codezeile.

flowchart LR
  A([Order 1, 100 ms]) --> B([Order 2, 70 ms]) --> C([Order 3, 80 ms]) --> D([Nachfolgende<br>Anweisungen])

Beim synchronen Übermitteln der obigen Orders muss Ihr cBot insgesamt 250 ms aufwenden, bevor er mit den Anweisungen fortfährt, die nach Order 3 angegeben sind.

Andererseits ermöglicht die asynchrone Ausführung cTrader, mehrere Orders parallel zu senden, ohne eine Antwort vom Server zu erwarten. Durch die Verwendung asynchroner Programmierung kann eine Strategie die Gesamtzeit minimieren, die für die Ausführung mehrerer Orders erforderlich ist.

flowchart LR
  subgraph Orders ["Orders"]
    direction TB
    A([Order 1, 100 ms]) --- B([Order 2, 70 ms]) --- C([Order 3, 80 ms])
  end
  D([Nachfolgende<br>Anweisungen])
  Orders --> D

Im obigen Diagramm werden alle drei Orders genau zur gleichen Zeit übermittelt und der cBot wartet nicht auf deren Ausführungsergebnisse, bevor er mit nachfolgenden Anweisungen fortfährt.

Codebeispiele

Wir können auch Code verwenden, um zu demonstrieren, wie die synchrone Ausführung funktioniert.

1
2
3
4
5
6
7
8
9
protected override void OnStart()
{
    for (int i = 0; i < 10; i++)
    {
        ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000);
        Print("Order Sent");
        Print("Positions Count:" + Positions.Count); 
    }
}

Wenn wir einen cBot mit diesem Code ausführen, zeigt das Protokoll, dass die Positionsanzahl erst nach der Ausführung jeder Position steigt. Der Code wartet darauf, dass jede Order ausgeführt wird, bevor eine Anfrage zur Ausführung der nächsten gesendet wird.

Um zur asynchronen Orderausführung zu wechseln, können wir die Methode ExecuteMarketOrderAsync verwenden.

1
2
3
4
5
6
7
8
9
protected override void OnStart()
{
    for (int i = 0; i < 10; i++)
    {
        ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 1000);
        Print("Order Sent");
        Print("Positions Count:" + Positions.Count); 
    }
}

Wir fügen auch einen Event-Handler hinzu, um auf das Ereignis Positions.Opened zu lauschen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
protected override void OnStart()
{
    Positions.Opened += Positions_Opened;
    for (int i = 0; i < 10; i++)
    {
        ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 1000, PositionOpened);
        Print("Order Sent");
        Print("Positions Count:" + Positions.Count); 
    }
}

In unserem Event-Handler geben wir eine Nachricht im Protokoll aus, sobald eine Position eröffnet wurde, sowie die Anzahl der offenen Positionen zu diesem Zeitpunkt.

Wenn wir einen cBot mit diesem Code ausführen und einen Blick auf das Protokoll werfen, werden wir sehen, dass alle Orders gesendet wurden, ohne eine Bestätigung über die Ergebnisse vorheriger Anweisungen zu erhalten. Der Positionszähler ist die ganze Zeit bei 0 geblieben. Bestätigungen trafen ein und wurden einige Millisekunden, nachdem alle Orders an den Server gesendet wurden, im Protokoll ausgegeben.

Callback-Orders verwenden

Jetzt können wir zu unserem Quellcode zurückkehren und eine weitere wertvolle Funktion der asynchronen Ausführung demonstrieren, nämlich die Option, Callback-Methoden zu verwenden, die aufgerufen werden, sobald die Orderausführung abgeschlossen ist. Wir entfernen unseren Handler des Ereignisses Positions.Opened und implementieren eine Callback-Methode, die eine Bestätigung ausgibt, sobald eine Order ausgeführt wurde.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
private void TradeExecuted(TradeResult tradeResult)
{
    if (tradeResult.IsSuccessful)
    {
        Print("Trade succeeded. Position Opened.");
    }
    else
    {
        Print("Trade failed. Position Not Opened.");
    }
}

Wir übergeben diese Methode dann als Argument an die Methode ExecuteMarketOrderAsync.

1
ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 1000, TradeExecuted);

Im Gegensatz zu unserem früheren Ansatz wird die Callback-Methode unabhängig davon aufgerufen, ob ein Trade erfolgreich war, was auch bedeutet, dass Sie über nicht erfolgreiche Trades informiert werden und entsprechend handeln können.

Den Status der asynchronen Ausführung überwachen

cTrader bietet auch ein benutzerfreundliches Tool zur Verfolgung des Status asynchroner Trades. Die Methode ExecuteMarketOrderAsync gibt ein Objekt TradeOperation zurück, das Informationen darüber enthält, ob die Order noch ausgeführt wird.

Wir können damit beginnen, ein neues Feld zu deklarieren.

1
TradeOperation _tradeOperation;

Wir entfernen dann unsere for-Schleife und weisen das Ergebnis der Orderausführung dem neuen Feld zu.

1
_tradeOperation = ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 1000, TradeExecuted);

Wir fügen unserem cBot auch einen Timer hinzu. Der Timer überprüft alle 100 Millisekunden den Status einer Operation.

1
2
Timer.TimerTick += Timer_TimerTick;
Timer.Start(new System.TimeSpan(0, 0, 0, 0, 100));

Wenn eine Operation noch ausgeführt wird, gibt der Timer dies im Protokoll aus.

1
2
3
4
5
6
7
8
private void Timer_TimerTick()
{
    Print("Tick");
    if (_tradeOperation != null)
    {
        Print("Trade operation is executing: " + _tradeOperation.IsExecuting);
    }
}

Nachdem der cBot erstellt wurde, können wir testen, wie er auf einem Demo-Konto funktioniert. Im Protokoll sollte der Timer regelmäßige Updates zum Status der asynchronen Ausführung ausgeben.

Zusammenfassung

Die asynchrone Ausführung ist ein leistungsstarkes Tool, das die automatische Orderübermittlung im Vergleich zur synchronen Programmierung erheblich beschleunigen kann. Die synchrone Ausführung kann jedoch weiterhin verwendet werden, falls Sie das Ergebnis eines Trades kennen müssen, bevor Sie mit dem nächsten Schritt fortfahren. Die asynchrone Ausführung hingegen wird am besten verwendet, wenn Sie mehrere Orders parallel ohne Verzögerungen senden müssen.