Aller au contenu

Opérations de trading cBot

Dans ce guide, nous expliquons en détail les principales opérations de trading que vous pouvez exécuter à l'aide d'un cBot développé via Algo API.

Voici quelques-unes des opérations prises en charge pour les cBots :

  • Envoi d'ordres de marché.
  • Placement d'ordres en cours.
  • Modification des ordres en cours et des positions ouvertes.
  • Fermeture de positions et annulation d'ordres.
  • Abonnement aux événements de trading (positions, ordres et activité connexe).

Envoyez des ordres de marché

Un ordre de marché est envoyé au serveur de trading lorsque la méthode ExecuteMarketOrder() est appelée. Après avoir créé un nouveau cBot, vous pouvez ajouter cette méthode avec plusieurs propriétés définies de l'ordre de marché (symbole, volume, take profit, stop loss, etc.). L'exemple ci-dessous place un ordre de marché au démarrage du cBot.

 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)

Astuce

Dans l'exemple, plusieurs paramètres d'ordre ont été intentionnellement laissés non définis "". Consultez Références pour les signatures et l'ordre de tous les paramètres ExecuteMarketOrder().

Lors de la construction du cBot et de l'ajout d'une instance, vous verrez qu'un ordre de marché avec les paramètres spécifiés a été exécuté au démarrage. Les onglets Positions et Journal du panneau Trade Watch affichent la position correspondante et les entrées du journal.

Positions

Log

Placez des ordres en cours

cTrader prend en charge trois types d'ordres en cours, à savoir les ordres stop, les ordres limit et les ordres stop-limit. Pour placer des ordres en cours au démarrage, vous pouvez remplacer l'ordre de marché par les extraits de code suivants dans l'exemple de cBot précédent.

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)

Astuce

Pour inspecter rapidement les paramètres d'une méthode, commencez à taper le nom de la méthode et une parenthèse ouvrante. Vous verrez une fenêtre contextuelle IntelliSense avec des informations supplémentaires.

Image title

Astuce

Si vous cliquez sur une méthode/un paramètre dans cTrader Algo et appuyez sur F1, le panneau d'aide à droite de la fenêtre de code affichera les résultats de recherche correspondants. Si le curseur de texte reste en dehors de la fenêtre de code et que vous appuyez sur F1, la fenêtre Centre d'aide apparaîtra pour vous aider.

Vous verrez les enregistrements suivants dans le panneau Trade Watch après la construction et l'exécution réussies du cBot.

Ordres

Log

Modifiez les ordres en cours et les positions ouvertes

Lorsque les ordres en cours sont placés, ils deviennent disponibles dans votre collection PendingOrders du cBot. Grâce à cette collection, vous pouvez y accéder et les modifier. Les ordres en cours existants peuvent être modifiés en ajustant leur niveau de stop loss comme suit.

 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)

L'onglet Journal du panneau Trade Watch affiche que les trois ordres en cours ont été modifiés avec succès immédiatement après avoir été placés.

Image title

Une fois que les différents types d'ordres sont exécutés avec succès, des positions seront ouvertes pour votre compte. Toutes les positions ouvertes sont disponibles dans la collection Positions de votre cBot. De la même manière que pour modifier les ordres en cours dans l'exemple précédent, vous pouvez modifier la position ouverte. Étant donné que les ordres de marché sont le moyen le plus rapide d'ouvrir des positions, ajoutons la méthode OnBar() avec une action de modification de position au premier cBot de ce guide.

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)

Comme le reflète le journal, la position ouverte a été modifiée sur la première barre ouverte.

Image title

Fermez les positions et annulez les ordres

Vous trouverez ci-dessous un exemple de cBot qui ferme toutes les positions ouvertes et annule tous les ordres en cours le vendredi à 11h00 (UTC) en appelant la méthode OnTick().

 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

S'abonner aux événements de trading

cTrader permet aux développeurs d'algorithmes de s'abonner aux événements de trading et de surveiller l'activité de trading, que celle-ci ait été initiée par un cBot ou manuellement. Cela est réalisé en écoutant les événements disponibles dans les deux collections présentées précédemment, Positions et PendingOrders.

Il existe trois événements disponibles pour les positions :

  • Open
  • Modified
  • Closed

Ils sont déclenchés lorsque vous ouvrez, modifiez et fermez les positions sur votre compte, respectivement.

Dans l'extrait de code ci-dessous, les trois événements sont déclarés dans la méthode OnStart() et les méthodes à appeler sont assignées. Celles-ci créeront automatiquement les signatures de code que nous pourrons utiliser. Ensuite, des instructions Print() sont ajoutées à chacune des méthodes d'événement.

 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")

Que ce soit vous ou le cBot qui effectue les événements Open, Modified et Closed, l'algorithme y réagira à chaque fois avec des messages imprimés comme indiqué dans le journal ci-dessous.

Image title

De même, vous pouvez vous abonner aux événements liés aux ordres en cours. Il existe quatre événements disponibles pour les ordres en cours :

  • Created
  • Modified
  • Filled
  • Cancelled

Les quatre événements sont déclarés dans la méthode OnStart(), et les gestionnaires d'événements sont ajoutés comme suit.

 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")

S'il est abonné aux événements liés aux ordres en cours, le cBot réagira aux activités de trading manuelles et programmées.

Image title

Résumé

Pour conclure, cTrader équipe les développeurs d'algorithmes d'un arsenal impressionnant d'opérations de trading qui peuvent être exécutées par les cBots. En les appliquant habilement, vous pouvez poursuivre des stratégies de trading personnalisées et sophistiquées.

Image title