Exécution parallèle des ordres dans cTrader

L'une des fonctionnalités qui distinguent cTrader est la possibilité d'utiliser à la fois la programmation synchrone et asynchrone pour exécuter vos ordres. Vous pouvez utiliser la programmation synchrone pour mettre en œuvre des stratégies qui doivent attendre les résultats de l'exécution des ordres avant de poursuivre ; alternativement, la programmation asynchrone est mieux utilisée lors de la création d'une stratégie à haute vitesse qui peut soumettre plusieurs ordres simultanément.

Dans cette vidéo et l'article correspondant, nous expliquerons la différence entre l'exécution synchrone et asynchrone et nous vous montrerons comment utiliser ces deux approches pour passer de nouveaux ordres.

Exécution d'ordres synchrone vs asynchrone

Flux de base

L'exécution synchrone d'ordres peut être expliquée à l'aide d'un simple diagramme. Lors du passage de nouveaux ordres de manière synchrone, un cBot doit attendre qu'un ordre soit exécuté avant de suivre toute autre instruction. En d'autres termes, cTrader envoie un ordre au serveur, attend la réponse, et ce n'est qu'ensuite qu'il commence à exécuter la ligne de code suivante.

flowchart LR
  A([Ordre 1, 100 ms]) --> B([Ordre 2, 70 ms]) --> C([Ordre 3, 80 ms]) --> D([Instructions<br>suivantes])

Lors du passage des ordres ci-dessus de manière synchrone, votre cBot devra passer un total de 250 ms avant de passer aux instructions spécifiées après l'Ordre 3.

D'autre part, l'exécution asynchrone permet à cTrader d'envoyer plusieurs ordres en parallèle sans attendre de réponse du serveur. En utilisant la programmation asynchrone, une stratégie peut minimiser le temps total requis pour exécuter plusieurs ordres.

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

Dans le diagramme ci-dessus, les trois ordres sont soumis exactement au même moment et le cBot n'attend pas les résultats de leur exécution avant de passer aux instructions suivantes.

Exemples de code

Nous pouvons également utiliser du code pour démontrer comment fonctionne l'exécution synchrone.

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

Si nous exécutons un cBot avec ce code, le journal montrera que le nombre de positions n'augmente qu'après l'exécution de chaque position. Le code attend que chaque ordre soit exécuté avant d'envoyer une demande d'exécution du suivant.

Pour passer à l'exécution d'ordres asynchrone, nous pouvons utiliser la méthode 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); 
    }
}

Nous ajouterons également un gestionnaire d'événements pour écouter l'événement 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); 
    }
}

Dans notre gestionnaire d'événements, nous imprimerons un message dans le journal dès qu'une position s'est ouverte ainsi que le nombre de positions ouvertes à ce moment-là.

Si nous exécutons un cBot avec ce code et jetons un coup d'œil au journal, nous verrons que tous les ordres ont été envoyés sans recevoir de confirmation sur les résultats des instructions précédentes. Le compteur de positions est resté à 0 tout le temps. Les confirmations sont arrivées et ont été imprimées dans le journal quelques millisecondes après que tous les ordres ont été envoyés au serveur.

Utiliser les ordres de rappel

Nous pouvons maintenant revenir à notre code source et démontrer une autre fonctionnalité précieuse de l'exécution asynchrone, à savoir l'option d'utiliser des méthodes de rappel qui sont appelées dès que l'exécution de l'ordre est terminée. Nous supprimerons notre gestionnaire de l'événement Positions.Opened et implémenterons une méthode de rappel qui imprime une confirmation une fois qu'un ordre a été exécuté.

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

Nous passerons ensuite cette méthode comme argument à la méthode ExecuteMarketOrderAsync.

1

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

Contrairement à notre approche précédente, la méthode de rappel sera appelée que le trade ait réussi ou non, ce qui signifie également que vous êtes informé des trades non réussis et pouvez agir en conséquence.

Surveiller le statut de l'exécution asynchrone

cTrader fournit également un outil facile à utiliser pour suivre le statut des trades asynchrones. La méthode ExecuteMarketOrderAsync renvoie un objet TradeOperation qui contient des informations sur le fait que l'ordre est toujours en cours d'exécution.

Nous pouvons commencer par déclarer un nouveau champ.

1

TradeOperation _tradeOperation;

Nous supprimerons ensuite notre boucle for et attribuerons le résultat de l'exécution de l'ordre au nouveau champ.

1

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

Nous ajouterons également un minuteur à notre cBot. Le minuteur vérifiera le statut d'une opération toutes les 100 millisecondes.

1
2

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

Si une opération est toujours en cours d'exécution, le minuteur l'imprimera dans le journal.

1
2
3
4
5
6
7
8

private void Timer_TimerTick()
{
    Print("Tick");
    if (_tradeOperation != null)
    {
        Print("Trade operation is executing: " + _tradeOperation.IsExecuting);
    }
}

Une fois le cBot construit, nous pouvons tester son fonctionnement sur un compte de démo. Dans le journal, le minuteur devrait imprimer des mises à jour régulières sur le statut de l'exécution asynchrone.

Résumé

L'exécution asynchrone est un outil puissant qui peut rendre le passage automatique d'ordres beaucoup plus rapide par rapport à la programmation synchrone. Cependant, l'exécution synchrone peut toujours être utilisée au cas où vous auriez besoin de connaître le résultat d'un trade avant de passer à l'étape suivante. L'exécution asynchrone, quant à elle, est mieux utilisée lorsque vous devez envoyer plusieurs ordres en parallèle sans aucun délai.