Vai al contenuto

Esecuzione parallela degli ordini in cTrader

Una delle funzionalità che contraddistingue cTrader è la possibilità di utilizzare sia la programmazione sincrona che quella asincrona per eseguire i tuoi ordini. Puoi utilizzare la programmazione sincrona per implementare strategie che devono attendere i risultati dell'esecuzione dell'ordine prima di procedere ulteriormente; in alternativa, la programmazione asincrona è più adatta quando si crea una strategia ad alta velocità in grado di inviare più ordini contemporaneamente.

In questo video e nel relativo articolo spiegheremo la differenza tra esecuzione sincrona e asincrona e ti mostreremo come utilizzare entrambi questi approcci per piazzare nuovi ordini.

Esecuzione sincrona vs asincrona degli ordini

Flussi di base

L'esecuzione sincrona degli ordini può essere spiegata utilizzando un semplice diagramma. Quando si piazzano nuovi ordini in modo sincrono, un cBot deve attendere che un ordine venga eseguito prima di seguire qualsiasi altra istruzione. In altre parole, cTrader invia un ordine al server, attende la risposta e solo allora inizia a eseguire la riga di codice successiva.

flowchart LR
  A([Ordine 1, 100 ms]) --> B([Ordine 2, 70 ms]) --> C([Ordine 3, 80 ms]) --> D([Istruzioni<br>successive])

Quando si piazzano gli ordini di cui sopra in modo sincrono, il tuo cBot dovrà impiegare un totale di 250 ms prima di procedere a qualsiasi istruzione specificata dopo l'Ordine 3.

D'altra parte, l'esecuzione asincrona consente a cTrader di inviare più ordini in parallelo senza aspettarsi una risposta dal server. Utilizzando la programmazione asincrona, una strategia può ridurre al minimo il tempo totale richiesto per l'esecuzione di più ordini.

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

Nel diagramma sopra, tutti e tre gli ordini vengono inviati esattamente nello stesso momento e il cBot non attende i risultati della loro esecuzione prima di procedere alle istruzioni successive.

Esempi di codice

Possiamo anche utilizzare il codice per dimostrare come funziona l'esecuzione sincrona.

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); 
    }
}

Se eseguiamo un cBot con questo codice, il registro mostrerà che il conteggio delle posizioni aumenta solo dopo l'esecuzione di ciascuna posizione. Il codice attende che ogni ordine venga eseguito prima di inviare una richiesta per eseguire quello successivo.

Per passare all'esecuzione asincrona degli ordini, possiamo utilizzare il metodo ExecuteMarketOrderAsync.

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); 
    }
}

Aggiungeremo anche un gestore di eventi per ascoltare l'evento Positions.Opened.

 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); 
    }
}

Nel nostro gestore di eventi stamperemo un messaggio nel registro non appena una posizione viene aperta, nonché il numero di posizioni aperte in quel momento.

Se eseguiamo un cBot con questo codice e diamo un'occhiata al registro, vedremo che tutti gli ordini sono stati inviati senza ricevere una conferma sui risultati delle istruzioni precedenti. Il contatore delle posizioni è rimasto a 0 per tutto il tempo. Le conferme sono arrivate e sono state stampate nel registro alcuni millisecondi dopo che tutti gli ordini sono stati inviati al server.

Utilizzare ordini con callback

Ora possiamo tornare al nostro codice sorgente e dimostrare un'altra funzionalità preziosa dell'esecuzione asincrona, ovvero l'opzione di utilizzare metodi di callback che vengono chiamati non appena l'esecuzione dell'ordine è terminata. Rimuoveremo il nostro gestore dell'evento Positions.Opened e implementeremo un metodo di callback che stampa una conferma una volta che un ordine è stato eseguito.

 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.");
    }
}

Passeremo quindi questo metodo come argomento al metodo ExecuteMarketOrderAsync.

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

A differenza del nostro approccio precedente, il metodo di callback verrà chiamato indipendentemente dal fatto che un'operazione sia riuscita o meno, il che significa anche che vieni informato delle operazioni non riuscite e puoi agire di conseguenza.

Monitorare lo stato dell'esecuzione asincrona

cTrader fornisce anche uno strumento facile da usare per monitorare lo stato delle operazioni asincrone. Il metodo ExecuteMarketOrderAsync restituisce un oggetto TradeOperation che contiene informazioni sul fatto che l'ordine sia ancora in esecuzione.

Possiamo iniziare dichiarando un nuovo campo.

1
TradeOperation _tradeOperation;

Rimuoveremo quindi il nostro ciclo for e assegneremo il risultato dell'esecuzione dell'ordine al nuovo campo.

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

Aggiungeremo anche un timer al nostro cBot. Il timer controllerà lo stato di un'operazione ogni 100 millisecondi.

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

Se un'operazione è ancora in esecuzione, il timer lo stamperà nel registro.

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

Dopo che il cBot è stato compilato, possiamo testare come funziona su un conto demo. Nel registro, il timer dovrebbe stampare aggiornamenti regolari sullo stato dell'esecuzione asincrona.

L'esecuzione asincrona è uno strumento potente che può rendere il piazzamento automatico degli ordini molto più rapido rispetto alla programmazione sincrona. Tuttavia, l'esecuzione sincrona può ancora essere utilizzata nel caso in cui tu debba conoscere l'esito di un'operazione prima di procedere al passaggio successivo. L'esecuzione asincrona, d'altra parte, è più adatta quando è necessario inviare più ordini in parallelo senza ritardi.