MQL4 · Ordres
OrderDelete en MQL4 : supprimer un ordre en attente
OrderDelete supprime un ordre en attente en MQL4. Signature, boucle de nettoyage, ordre qui annule l’autre, expiration simulée, fin de session et refus liés à la zone de gel.
OrderDelete() supprime un ordre en attente (OP_BUYLIMIT, OP_SELLLIMIT, OP_BUYSTOP, OP_SELLSTOP) qui n’a pas encore été déclenché. Sa signature est bool OrderDelete(int ticket, color arrow_color=clrNONE) : il suffit du ticket de l’ordre. La fonction renvoie true si la suppression a réussi, false sinon, avec un code lisible par GetLastError(). Elle ne ferme pas une position ouverte : pour un ordre au marché, c’est OrderClose() qu’il faut utiliser. La suppression peut être refusée lorsque le prix est trop proche du niveau de déclenchement, dans la zone de gel définie par le courtier.
Cette page montre comment supprimer un ordre en attente, comment nettoyer tous ceux d’un EA, et comment programmer trois cas d’usage fréquents : l’ordre qui annule l’autre, l’expiration simulée et le nettoyage en fin de session. Elle fait partie de la rubrique Gérer les ordres en MQL4.
Ce que fait exactement OrderDelete
Un ordre en attente est une instruction stockée sur le serveur : « achète si le prix atteint tel niveau », « vends si le prix descend sous tel niveau ». Tant qu’il n’est pas déclenché, il ne mobilise pas de position et ne produit ni gain ni perte. OrderDelete() retire cette instruction. L’ordre passe alors dans l’historique du compte (pool MODE_HISTORY), avec une date de clôture, ce qui permet de le retrouver plus tard.
Si l’ordre a été déclenché entre le moment où votre EA l’a sélectionné et celui où il demande la suppression, il est devenu un ordre au marché : la suppression échoue. C’est un cas réel, en particulier sur les ordres stop placés près du prix pendant des mouvements rapides. Votre code doit donc vérifier le type de l’ordre juste avant l’appel et, en cas d’échec, relire l’ordre pour savoir ce qu’il est devenu.
Supprimer les ordres en attente d’un EA
#property strict
input int InpMagic = 240204; // Numéro magique de l'EA
//+------------------------------------------------------------------+
//| Vrai si le type correspond à un ordre en attente |
//+------------------------------------------------------------------+
bool EstEnAttente(int type)
{
return(type == OP_BUYLIMIT || type == OP_SELLLIMIT ||
type == OP_BUYSTOP || type == OP_SELLSTOP);
}
//+------------------------------------------------------------------+
//| Supprime les ordres en attente de l'EA sur le symbole courant. |
//| typeCible = -1 pour tous les types, sinon un type OP_... |
//| Renvoie le nombre d'échecs |
//+------------------------------------------------------------------+
int SupprimerAttentes(int typeCible = -1)
{
int echecs = 0;
for(int i = OrdersTotal() - 1; i >= 0; i--) // boucle descendante
{
if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
if(OrderSymbol() != Symbol() || OrderMagicNumber() != InpMagic) continue;
if(!EstEnAttente(OrderType())) continue; // on ne touche pas aux positions
if(typeCible >= 0 && OrderType() != typeCible) continue;
int ticket = OrderTicket();
ResetLastError();
if(!OrderDelete(ticket, clrNONE))
{
int err = GetLastError();
PrintFormat("OrderDelete %d échoué : erreur %d", ticket, err);
echecs++;
}
}
return(echecs);
}
La structure est la même que pour la fermeture des positions : boucle descendante, filtre par symbole et numéro magique, puis filtre par type. Le paramètre typeCible permet de ne supprimer, par exemple, que les ordres d’achat stop. Pour les détails de la boucle et des filtres, voyez OrderSelect et boucles.
Cas d’usage 1 : un ordre annule l’autre
Les stratégies de cassure placent souvent un achat stop au-dessus d’un range et une vente stop en dessous. Dès que l’un des deux est déclenché, l’autre doit disparaître, sinon un retournement du marché ouvrirait une deuxième position dans le sens opposé. MetaTrader 4 ne propose pas ce mécanisme côté serveur : c’est à l’EA de le gérer.
//+------------------------------------------------------------------+
//| Si une position de l'EA existe, supprimer les ordres en attente |
//+------------------------------------------------------------------+
void GererOCO()
{
bool positionOuverte = false;
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
if(OrderSymbol() != Symbol() || OrderMagicNumber() != InpMagic) continue;
if(OrderType() == OP_BUY || OrderType() == OP_SELL)
{
positionOuverte = true;
break;
}
}
if(positionOuverte)
SupprimerAttentes(); // l'un est parti : on annule les autres
}
void OnTick()
{
GererOCO();
}
Appelée à chaque tick, cette fonction réagit dès la première cotation qui suit le déclenchement. Il reste une fenêtre de risque entre le déclenchement et la suppression : sur un mouvement très rapide, les deux ordres peuvent théoriquement être déclenchés avant que l’EA n’ait pu réagir. Vérifiez ce cas dans votre code et décidez explicitement de ce que doit faire l’EA s’il trouve deux positions opposées.
Cas d’usage 2 : simuler une expiration
OrderSend() et OrderModify() acceptent une date d’expiration pour les ordres en attente, mais certains serveurs la refusent avec l’erreur 147. La solution portable consiste à gérer l’expiration dans l’EA : comparer l’heure du serveur à l’heure de placement de l’ordre, lue avec OrderOpenTime(), et supprimer l’ordre au-delà d’une durée paramétrable.
input int InpDureeMinutes = 240; // Durée de vie d'un ordre en attente
void ExpirerAttentes()
{
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
if(OrderSymbol() != Symbol() || OrderMagicNumber() != InpMagic) continue;
if(!EstEnAttente(OrderType())) continue;
// pour un ordre en attente, OrderOpenTime() est l'heure de placement
if(TimeCurrent() - OrderOpenTime() > InpDureeMinutes * 60)
if(!OrderDelete(OrderTicket()))
PrintFormat("Expiration de %d impossible : erreur %d", OrderTicket(), GetLastError());
}
}
Cette expiration logicielle a une limite : elle ne fonctionne que si l’EA tourne. Si le terminal est arrêté, l’ordre reste actif sur le serveur. C’est une raison de plus pour faire tourner un EA de production sur une machine allumée en permanence.
Cas d’usage 3 : nettoyage en fin de session
Un EA qui place des ordres en attente pendant une session donnée doit souvent les retirer à la fin de celle-ci, et avant le week-end pour éviter un déclenchement sur l’écart d’ouverture du lundi. Il suffit d’appeler SupprimerAttentes() lorsque l’heure du serveur atteint la limite fixée, avec les fonctions décrites dans Fonctions de temps.
Les refus de suppression
- Zone de gel. La documentation des limites de trading précise que la possibilité de supprimer un ordre en attente est régie par le paramètre FreezeLevel : si le prix du marché est trop proche du prix de déclenchement, la suppression est refusée. Voir StopLevel et FreezeLevel.
- Ordre déjà déclenché ou supprimé. Le ticket ne correspond plus à un ordre en attente. Relisez l’ordre par son ticket pour savoir s’il est devenu une position ou s’il est dans l’historique.
- Contexte de trading occupé (146). Attendez et retentez.
- Trading non autorisé. Bouton de trading automatique désactivé ou autorisation de l’EA décochée.
Vérifier après la suppression
Une suppression réussie ne garantit pas que l’EA est dans l’état attendu : un autre ordre peut avoir été déclenché entre-temps. Après un nettoyage, relancez un comptage avec la fonction de comptage par type décrite dans la page OrderSelect, et comparez le résultat à ce que la stratégie prévoit. Si une position inattendue est apparue, l’EA doit appliquer une règle définie à l’avance : la conserver avec son stop, ou la fermer immédiatement. L’important est que ce choix soit écrit dans le code et documenté, plutôt que découvert au moment de l’incident.
Pièges fréquents
- Supprimer sans filtrer le type : appliquer
OrderDelete()à une position ouverte échoue, et le contraire (OrderClose()sur un ordre en attente) aussi. Testez toujoursOrderType(). - Oublier les ordres orphelins : quand la position principale est fermée par son stop, les ordres en attente associés (renforts, ordres opposés) restent actifs si l’EA ne les nettoie pas.
- Boucler en montant : comme pour les fermetures, chaque suppression décale les indices.
- Supprimer et replacer à chaque tick : certains EA déplacent leurs ordres en supprimant puis en recréant, ce qui multiplie les requêtes. Pour déplacer un ordre en attente,
OrderModify()est plus économe et conserve le ticket. - Négliger le journal : chaque échec de suppression doit apparaître avec son code, sinon un ordre resté actif passe inaperçu jusqu’à son déclenchement.
Et en MQL5 ?
En MQL5, la suppression d’un ordre en attente passe par l’action TRADE_ACTION_REMOVE d’une requête de trading, ou par la méthode CTrade::OrderDelete(). Les ordres en attente y sont listés séparément des positions, avec OrdersTotal() et OrderGetTicket(), ce qui évite d’avoir à filtrer le type. Voyez Des ordres MQL4 aux positions MQL5.
FAQ
Peut-on supprimer une position ouverte avec OrderDelete ?
Non. OrderDelete() ne concerne que les ordres en attente non déclenchés. Une position se ferme avec OrderClose().
Pourquoi ma suppression est-elle refusée alors que l’ordre existe ?
Le prix est probablement trop proche du niveau de déclenchement, dans la zone de gel du courtier, ou l’ordre vient d’être déclenché. Relisez l’ordre et réessayez plus tard.
Un ordre supprimé apparaît-il dans l’historique ?
Oui, il passe dans le pool MODE_HISTORY et peut être retrouvé avec OrderSelect() sur l’historique.
Comment annuler l’ordre opposé quand l’un des deux est déclenché ?
L’EA doit le faire lui-même : à chaque tick, s’il trouve une position ouverte avec son numéro magique, il supprime ses ordres en attente restants.
