Vai al contenuto

Operazioni di trading del cBot

In questa guida spieghiamo in dettaglio le principali operazioni di trading che puoi eseguire utilizzando un cBot sviluppato tramite Algo API.

Queste sono alcune delle operazioni supportate per i cBot:

  • Invio di ordini di mercato.
  • Piazzamento di ordini in sospeso.
  • Modifica di ordini in sospeso e posizioni aperte.
  • Chiusura di posizioni e annullamento di ordini.
  • Sottoscrizione agli eventi di trading (posizioni, ordini e attività correlate).

Invia ordini di mercato

Un ordine di mercato viene inviato al server di trading quando viene chiamato il metodo ExecuteMarketOrder(). Dopo aver creato un nuovo cBot, puoi aggiungere questo metodo con diverse proprietà definite dell'ordine di mercato (simbolo, volume, take profit, stop loss, ecc.). L'esempio seguente piazza un ordine di mercato quando il cBot viene avviato.

 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)

Suggerimento

Nell'esempio, diversi parametri dell'ordine sono stati intenzionalmente lasciati indefiniti "". Consulta References per le firme e l'ordine di tutti i parametri di ExecuteMarketOrder().

Dopo aver compilato il cBot e aggiunto un'istanza, vedrai che un ordine di mercato con i parametri specificati è stato eseguito all'avvio. Le schede Positions e Log nel pannello Vista trading mostrano la posizione corrispondente e le voci del registro.

Positions

Log

Piazza ordini in sospeso

cTrader supporta tre tipi di ordini in sospeso, ovvero ordini stop, ordini limite e ordini stop limit. Per piazzare ordini in sospeso all'avvio, puoi sostituire l'ordine di mercato con i seguenti frammenti di codice nell'esempio precedente del cBot.

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)

Suggerimento

Per ispezionare rapidamente i parametri di un metodo, inizia a digitare il nome del metodo e una parentesi di apertura. Vedrai un pop-up IntelliSense con informazioni aggiuntive.

Image title

Suggerimento

Se fai clic su un metodo/parametro in cTrader Algo e premi F1, il pannello della guida a destra della finestra del codice mostrerà i risultati di ricerca corrispondenti. Se il cursore di testo rimane al di fuori della finestra del codice e premi F1, apparirà la finestra Help Centre per assisterti.

Vedrai i seguenti record nel pannello Vista trading dopo aver compilato ed eseguito con successo il cBot.

Orders

Log

Modifica ordini in sospeso e posizioni aperte

Quando gli ordini in sospeso vengono piazzati, diventano disponibili nella tua raccolta PendingOrders del cBot. Tramite questa raccolta, puoi accedervi e modificarli. Gli ordini in sospeso esistenti possono essere modificati regolando il loro livello di stop loss come segue.

 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)

La scheda Log del pannello Vista trading mostra che i tre ordini in sospeso sono stati modificati con successo immediatamente dopo essere stati piazzati.

Image title

Dopo che i diversi tipi di ordine sono stati eseguiti con successo, verranno aperte delle posizioni per il tuo conto. Tutte le posizioni aperte sono disponibili nella raccolta Positions del tuo cBot. Analogamente alla modifica degli ordini in sospeso nell'esempio precedente, puoi modificare la posizione aperta. Poiché gli ordini di mercato sono il modo più veloce per aprire posizioni, aggiungiamo il metodo OnBar() con un'azione di modifica della posizione al primo cBot di questa guida.

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)

Come riflesso nel registro, la posizione aperta è stata modificata alla prima barra aperta.

Image title

Chiudi posizioni e annulla ordini

Puoi trovare un esempio di cBot qui sotto che chiude tutte le posizioni aperte e annulla tutti gli ordini in sospeso venerdì alle 11:00 (UTC) chiamando il metodo 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

Sottoscrivi agli eventi di trading

cTrader consente agli sviluppatori di algoritmi di sottoscrivere agli eventi di trading e monitorare l'attività di trading, indipendentemente dal fatto che siano stati avviati da un cBot o manualmente. Ciò si ottiene ascoltando gli eventi disponibili nelle due raccolte dimostrate in precedenza, Positions e PendingOrders.

Ci sono tre eventi disponibili per le posizioni:

  • Open
  • Modified
  • Closed

Vengono attivati quando apri, modifichi e chiudi le posizioni sul tuo conto, rispettivamente.

Nel frammento di codice seguente, i tre eventi sono dichiarati nel metodo OnStart() e vengono assegnati i metodi da chiamare. Questi creeranno automaticamente le firme del codice da utilizzare. Successivamente, vengono aggiunte istruzioni Print() a ciascuno dei metodi degli eventi.

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

Che sia tu o il cBot a eseguire gli eventi Open, Modified e Closed, l'algoritmo reagirà a essi ogni volta con messaggi stampati come mostrato nel registro qui sotto.

Image title

Allo stesso modo, puoi sottoscrivere agli eventi relativi agli ordini in sospeso. Ci sono quattro eventi disponibili per gli ordini in sospeso:

  • Created
  • Modified
  • Filled
  • Cancelled

I quattro eventi sono dichiarati nel metodo OnStart() e i gestori degli eventi vengono aggiunti come segue.

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

Se sottoscritto agli eventi relativi agli ordini in sospeso, il cBot reagirà sia alle attività di trading manuali che programmate.

Image title

Per concludere, cTrader fornisce agli sviluppatori di algoritmi un impressionante arsenale di operazioni di trading che possono essere eseguite dai cBot. Applicandole con abilità, puoi perseguire strategie di trading personalizzate e sofisticate.

Image title