Zum Inhalt

cBot-Handelsoperationen

In diesem Leitfaden erklären wir detailliert die wichtigsten Handelsoperationen, die Sie mit einem über die Algo API entwickelten cBot ausführen können.

Dies sind einige der unterstützten Operationen für cBots:

  • Senden von Markt-Orders.
  • Platzieren von ausstehenden Orders.
  • Ändern von ausstehenden Orders und offenen Positionen.
  • Schließen von Positionen und Stornieren von Orders.
  • Abonnieren von Handelsereignissen (Positionen, Orders und zugehörige Aktivitäten).

Markt-Orders senden

Eine Markt-Order wird an den Handelsserver gesendet, wenn die Methode ExecuteMarketOrder() aufgerufen wird. Nach dem Erstellen eines neuen cBots können Sie diese Methode mit mehreren definierten Eigenschaften der Markt-Order (Symbol, Volumen, Take-Profit, Stop-Loss usw.) hinzufügen. Das folgende Beispiel platziert eine Markt-Order, wenn der cBot startet.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class TradeOperations : Robot
    {
        protected override void OnStart()
        {
            ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000, "", 10, 10, "", false);
        }       
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import clr

clr.AddReference("cAlgo.API")

from cAlgo.API import *
from robot_wrapper import *

class TradeOperations():
    def on_start(self):
        api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 1000, "", 10, 10, "", False)

Tipp

Im Beispiel wurden mehrere Order-Parameter absichtlich undefiniert gelassen "". Prüfen Sie Referenzen für die Signaturen und die Reihenfolge aller ExecuteMarketOrder()-Parameter.

Beim Erstellen des cBots und Hinzufügen einer Instanz werden Sie sehen, dass eine Markt-Order mit den angegebenen Parametern beim Start ausgeführt wurde. Die Registerkarten Positionen und Log im Handelsüberwachungs-Panel zeigen die entsprechende Position und Log-Einträge an.

Positionen

Log

Ausstehende Orders platzieren

cTrader unterstützt drei Arten von ausstehenden Orders, nämlich Stop-Orders, Limit-Orders und Stop-Limit-Orders. Um ausstehende Orders beim Start zu platzieren, können Sie die Markt-Order durch die folgenden Code-Snippets im früheren cBot-Beispiel ersetzen.

1
2
3
PlaceStopOrder(TradeType.Buy, SymbolName, 1000, Symbol.Ask + (Symbol.PipSize * 10), "", 10, 10, null, "", false);
PlaceLimitOrder(TradeType.Buy, SymbolName, 1000, Symbol.Ask - (Symbol.PipSize * 10), "", 10, 10, null, "", false);
PlaceStopLimitOrder(TradeType.Buy, SymbolName, 1000, Symbol.Ask + (Symbol.PipSize * 10), 2, "", 10, 10, null, "", false);

1
2
3
api.PlaceStopOrder(TradeType.Buy, api.SymbolName, 1000, api.Symbol.Ask + (api.Symbol.PipSize * 10), "", 10, 10, None, "", False)
api.PlaceLimitOrder(TradeType.Buy, api.SymbolName, 1000, api.Symbol.Ask - (api.Symbol.PipSize * 10), "", 10, 10, None, "", False)
api.PlaceStopLimitOrder(TradeType.Buy, api.SymbolName, 1000, api.Symbol.Ask + (api.Symbol.PipSize * 10), 2, "", 10, 10, None, "", False)

Tipp

Um die Parameter einer Methode schnell zu überprüfen, beginnen Sie mit der Eingabe des Methodennamens und einer öffnenden Klammer. Sie sehen ein IntelliSense-Pop-up mit zusätzlichen Informationen.

Image title

Tipp

Wenn Sie in cTrader Algo auf eine Methode/einen Parameter klicken und F1 drücken, zeigt das Hilfefenster rechts neben dem Codefenster die passenden Suchergebnisse an. Wenn der Textcursor außerhalb des Codefensters bleibt und Sie F1 drücken, erscheint das Hilfe-Zentrum-Fenster, um Sie zu unterstützen.

Sie werden die folgenden Einträge im Handelsüberwachungs-Panel nach erfolgreichem Erstellen und Ausführen des cBots sehen.

Orders

Log

Ausstehende Orders und offene Positionen ändern

Wenn die ausstehenden Orders platziert sind, werden sie in Ihrer cBot-PendingOrders-Sammlung verfügbar. Über diese Sammlung können Sie auf sie zugreifen und sie ändern. Die bestehenden ausstehenden Orders können geändert werden, indem ihr Stop-Loss-Level wie folgt angepasst wird.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
protected override void OnStart()
{
    PlaceStopOrder(TradeType.Buy, SymbolName, 1000, Symbol.Ask + (Symbol.PipSize * 10), "", 10, 10, null, "", false);
    PlaceLimitOrder(TradeType.Buy, SymbolName, 1000, Symbol.Ask - (Symbol.PipSize * 10), "", 10, 10, null, "", false);
    PlaceStopLimitOrder(TradeType.Buy, SymbolName, 1000, Symbol.Ask + (Symbol.PipSize * 10), 2, "", 10, 10, null, "", false);

    foreach(var order in PendingOrders.Where(p => p.SymbolName == SymbolName))
    {
        order.ModifyStopLossPips(20);
    }
}     

1
2
3
4
5
6
7
8
def on_start(self):
    api.PlaceStopOrder(TradeType.Buy, api.SymbolName, 1000, api.Symbol.Ask + (api.Symbol.PipSize * 10), "", 10, 10, None, "", False)
    api.PlaceLimitOrder(TradeType.Buy, api.SymbolName, 1000, api.Symbol.Ask - (api.Symbol.PipSize * 10), "", 10, 10, None, "", False)
    api.PlaceStopLimitOrder(TradeType.Buy, api.SymbolName, 1000, api.Symbol.Ask + (api.Symbol.PipSize * 10), 2, "", 10, 10, None, "", False)

    for order in api.PendingOrders:
        if order.SymbolName == api.SymbolName:
            order.ModifyStopLossPips(20)

Die Registerkarte Log des Handelsüberwachungs-Panels zeigt an, dass die drei ausstehenden Orders unmittelbar nach ihrer Platzierung erfolgreich geändert wurden.

Image title

Nachdem die verschiedenen Order-Typen erfolgreich ausgeführt wurden, werden Positionen für Ihr Konto eröffnet. Alle offenen Positionen sind in der Positions-Sammlung Ihres cBots verfügbar. Ähnlich wie beim Ändern der ausstehenden Orders im vorherigen Beispiel können Sie die offene Position ändern. Da Markt-Orders der schnellste Weg sind, Positionen zu eröffnen, fügen wir dem ersten cBot in diesem Leitfaden die Methode OnBar() mit einer Positionsänderungsaktion hinzu.

1
2
3
4
5
6
7
protected override void OnBar()
{
    foreach(var position in Positions.Where(p => p.SymbolName == SymbolName))
    {
        position.ModifyTakeProfitPips(20);
    }
}

1
2
3
4
def on_bar(self):
    for position in api.Positions:
        if position.SymbolName == api.SymbolName:
            position.ModifyTakeProfitPips(20)

Wie im Log zu sehen ist, wurde die offene Position beim ersten geöffneten Balken geändert.

Image title

Positionen schließen und Orders stornieren

Sie finden unten ein cBot-Beispiel, das alle offenen Positionen schließt und alle ausstehenden Orders am Freitag um 11:00 Uhr (UTC) storniert, indem die Methode OnTick() aufgerufen wird.

 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
namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class TradeOperations : Robot
    {
        protected override void OnStart()
        {
            ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000, "", 10, 10, "", false);
            PlaceStopOrder(TradeType.Buy, SymbolName, 1000, Symbol.Ask + (Symbol.PipSize * 10), "", 10, 10, null, "", false);
        }  

        protected override void OnTick()
        {
            if(Server.Time.DayOfWeek == DayOfWeek.Friday && Server.Time.Hour >= 11)
            {
                foreach(var position in Positions.Where(p => p.SymbolName == SymbolName))
                {
                    position.Close();    
                }

                foreach(var order in PendingOrders.Where(p => p.SymbolName == SymbolName))
                {
                    order.Cancel();
                }
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
import clr
clr.AddReference("cAlgo.API")
from cAlgo.API import *
from robot_wrapper import *

class TradeOperations():
    def on_start(self):
        api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 1000, "", 10, 10, "", False)
        api.PlaceStopOrder(TradeType.Buy, api.SymbolName, 1000, api.Symbol.Ask + (api.Symbol.PipSize * 10), "", 10, 10, None, "", False)

    def on_tick(self):
        # Friday == 5 (Sunday=0)
        if api.Server.Time.DayOfWeek == 5 and api.Server.Time.Hour >= 11:
            for position in api.Positions:
                if position.SymbolName == api.SymbolName:
                    position.Close()
            for order in api.PendingOrders:
                if order.SymbolName == api.SymbolName:
                    order.Cancel()

Image title

Handelsereignisse abonnieren

cTrader ermöglicht es Algorithmus-Entwicklern, Handelsereignisse zu abonnieren und Handelsaktivitäten zu überwachen, unabhängig davon, ob diese von einem cBot oder manuell initiiert wurden. Dies wird erreicht, indem auf Ereignisse gehört wird, die in den beiden zuvor gezeigten Sammlungen verfügbar sind, Positions und PendingOrders.

Für Positionen stehen drei Ereignisse zur Verfügung:

  • Open
  • Modified
  • Closed

Sie werden ausgelöst, wenn Sie Positionen auf Ihrem Konto öffnen, ändern bzw. schließen.

Im folgenden Code-Snippet werden die drei Ereignisse in der Methode OnStart() deklariert und die aufzurufenden Methoden zugewiesen. Diese erstellen automatisch die Code-Signaturen für uns zur Verwendung. Anschließend werden Print()-Anweisungen zu jeder der Ereignismethoden hinzugefügt.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
protected override void OnStart()
{
    Positions.Opened += Positions_Opened;
    Positions.Modified += Positions_Modified;
    Positions.Closed += Positions_Closed;                    
}  

private void Positions_Opened(PositionOpenedEventArgs obj)
{
    Print("Position with ID " + obj.Position.Id + " was opened");
}

private void Positions_Modified(PositionModifiedEventArgs obj)
{
    Print("Position with ID " + obj.Position.Id + " was modified");
}

private void Positions_Closed(PositionClosedEventArgs obj)
{
    Print("Position with ID " + obj.Position.Id + " was closed");
}   

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def on_start(self):
    api.Positions.Opened += self.positions_opened
    api.Positions.Modified += self.positions_modified
    api.Positions.Closed += self.positions_closed

def positions_opened(self, obj):
    api.Print("Position with ID " + str(obj.Position.Id) + " was opened")

def positions_modified(self, obj):
    api.Print("Position with ID " + str(obj.Position.Id) + " was modified")

def positions_closed(self, obj):
    api.Print("Position with ID " + str(obj.Position.Id) + " was closed")

Egal ob Sie oder der cBot die Ereignisse Open, Modified und Closed ausführen, der Algorithmus wird jedes Mal mit gedruckten Nachrichten darauf reagieren, wie im folgenden Log gezeigt.

Image title

Ebenso können Sie Ereignisse im Zusammenhang mit ausstehenden Orders abonnieren. Für ausstehende Orders stehen vier Ereignisse zur Verfügung:

  • Created
  • Modified
  • Filled
  • Cancelled

Die vier Ereignisse werden in der Methode OnStart() deklariert und die Event-Handler werden wie folgt hinzugefügt.

 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
protected override void OnStart()
{
    PendingOrders.Created += PendingOrders_Created;
    PendingOrders.Modified += PendingOrders_Modified;
    PendingOrders.Filled += PendingOrders_Filled;
    PendingOrders.Cancelled += PendingOrders_Cancelled;
}

private void PendingOrders_Created(PendingOrderCreatedEventArgs obj)
{
    Print("Pending order with ID " + obj.PendingOrder.Id + " was created");
}

private void PendingOrders_Modified(PendingOrderModifiedEventArgs obj)
{
    Print("Pending order with ID " + obj.PendingOrder.Id + " was modified");
}

private void PendingOrders_Filled(PendingOrderFilledEventArgs obj)
{
    Print("Pending order with ID " + obj.PendingOrder.Id + " was filled");
}

private void PendingOrders_Cancelled(PendingOrderCancelledEventArgs obj)
{
    Print("Pending order with ID " + obj.PendingOrder.Id + " was cancelled");
}       

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
def on_start(self):
    api.PendingOrders.Created += self.pending_orders_created
    api.PendingOrders.Modified += self.pending_orders_modified
    api.PendingOrders.Filled += self.pending_orders_filled
    api.PendingOrders.Cancelled += self.pending_orders_cancelled

def pending_orders_created(self, obj):
    api.Print("Pending order with ID " + str(obj.PendingOrder.Id) + " was created")

def pending_orders_modified(self, obj):
    api.Print("Pending order with ID " + str(obj.PendingOrder.Id) + " was modified")

def pending_orders_filled(self, obj):
    api.Print("Pending order with ID " + str(obj.PendingOrder.Id) + " was filled")

def pending_orders_cancelled(self, obj):
    api.Print("Pending order with ID " + str(obj.PendingOrder.Id) + " was cancelled")

Wenn Sie die Ereignisse im Zusammenhang mit ausstehenden Orders abonniert haben, reagiert der cBot sowohl auf manuelle als auch auf programmierte Handelsaktivitäten.

Image title

Zusammenfassung

Zusammenfassend lässt sich sagen, dass cTrader Algorithmus-Entwickler mit einem beeindruckenden Arsenal an Handelsoperationen ausstattet, die von cBots ausgeführt werden können. Durch geschickte Anwendung können Sie maßgeschneiderte und ausgefeilte Handelsstrategien verfolgen.

Image title