Operazioni di Trading in MQL5 - È Facile
813
0
Quasi tutti i trader vengono sul mercato per fare soldi, ma alcuni trader apprezzano anche il processo in sé. Tuttavia, non è solo il trading manuale che ti può offrire un'esperienza entusiasmante. Anche lo sviluppo automatizzato dei sistemi di trading può essere piuttosto coinvolgente. Creare un robot di trading può essere interessante quanto leggere un buon romanzo giallo.
Quando sviluppiamo un algoritmo di trading, dobbiamo affrontare molti problemi tecnici, inclusi i più importanti:
- Cosa fare nel trading?
- Quando fare trading?
- Come fare trading?
Dobbiamo rispondere alla prima domanda per scegliere il simbolo più adatto. La nostra scelta può essere influenzata da molti fattori tra cui la capacità di automatizzare il nostro sistema di trading per il mercato. La seconda domanda riguarda l'elaborazione delle regole di trading che indicano chiaramente la direzione delle operazioni, nonché i punti di entrata e di uscita. La terza domanda sembra essere relativamente semplice: come comprare e vendere usando un linguaggio di programmazione definito?
In questo articolo, considereremo come implementare operazioni di trading nel trading algoritmico utilizzando il linguaggio MQL5.
Caratteristiche di MQL5 per Algo Trading
MQL5 è un linguaggio di programmazione di strategie di trading con molte funzioni di trading per lavorare con ordini, posizioni e richieste di trading. Pertanto, realizzare robot di trading algo in MQL5 è il compito meno laborioso per uno sviluppatore.
Le funzionalità MQL5 consentono di effettuare una richiesta di tradinge inviarla a un server utilizzando le funzioni OrderSend() o OrderSendAsync(), ricevere il risultato della sua elaborazione, visualizzare la cronologia di trading, esaminare le specifiche del contratto per un simbolo, gestire un evento di trading e ricevere altri dati necessari.
Inoltre, MQL5 può essere utilizzato per scrivere gli indicatori tecnici personalizzati e applicare quelli già implementati, disegnare eventuali segni e oggetti su un grafico, sviluppare un'interfaccia utente personalizzata, ecc. Esempi di implementazione possono essere visti in più articoli.
Operazioni di Trading: Facile come l’ABC!
Esistono diversi tipi di operazioni di trading di base che possono essere necessarie per il tuo robot di trading:
- acquisto/vendita al prezzo corrente,
- effettuare un ordine in sospeso per l'acquisto/vendita in base a una determinata condizione,
- modificare/eliminare un ordine in sospeso,
- chiudere/aggiungere/ridurre/invertire una posizione.
Tutte queste operazioni vengono eseguite utilizzando la funzione OrderSend(). Esiste anche una versione asincrona chiamata OrderSendAsync(). Tutta la varietà di operazioni commerciali è descritta dalla struttura MqlTradeRequest contenente una descrizione della richiesta di trading. Pertanto, solo il corretto riempimento della struttura MqlTradeRequest e la gestione dei risultati dell'esecuzione delle richieste possono essere difficili quando si tratta di operazioni di trading.
Secondo il tuo sistema di trading, puoi acquistare o vendere al prezzo di mercato (ACQUISTA o VENDI), oltre a piazzare un ordine di acquisto/vendita in sospeso a una certa distanza dal prezzo corrente di mercato:
- BUY STOP, SELL STOP - acquisto o vendita in caso di breakout di livello specificato (peggiore del prezzo corrente);
- BUY LIMIT, SELL LIMIT - acquisto o vendita nel caso in cui venga raggiunto un livello specificato (migliore del prezzo corrente);
- BUY STOP LIMIT, SELL STOP LIMIT - impostazione BUY LIMIT o SELL LIMIT nel caso in cui venga raggiunto un prezzo specificato.
Questi tipi di ordine standard corrispondono all’enumerazione ENUM_ORDER_TYPE.
Potrebbe essere necessario modificare o eliminare un ordine in sospeso. Ciò può essere fatto anche usando le funzioni OrderSend()/OrderSendAsync(). Anche la modifica di una posizione aperta è un processo abbastanza semplice, in quanto viene eseguito utilizzando le stesse operazioni di trading.
Se pensi che le operazioni di trading siano complesse ed intricate, è giunto il momento di cambiare idea. Mostreremo non solo come codificare acquisti e vendite in MQL5 in modo rapido e semplice, ma anche come lavorare con un account di trading e le proprietà dei simboli. Le classi di Trading ci aiuteranno in questa impresa.
Controlla il Tuo Account di Trading con CAccountInfo
La prima cosa che devi sapere quando avvii il tuo robot di trading è quale account di trading verrà utilizzato per il suo funzionamento. Poiché stiamo scrivendo un codice di formazione, implementeremo un controllo per il caso in cui l’Expert Advisor è stato lanciato su un account reale.
La classeCAccountInfo viene utilizzata per lavorare con un account. Aggiungeremo l'inclusione del file AccountInfo.mqh e dichiareremo la variabile della classe - account:
#include <Trade\AccountInfo.mqh> //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- object for working with the account CAccountInfo account; //--- receiving the account number, the Expert Advisor is launched at long login=account.Login(); Print("Login=",login); //--- clarifying account type ENUM_ACCOUNT_TRADE_MODE account_type=account.TradeMode(); //--- if the account is real, the Expert Advisor is stopped immediately! if(account_type==ACCOUNT_TRADE_MODE_REAL) { MessageBox("Trading on a real account is forbidden, disabling","The Expert Advisor has been launched on a real account!"); return(-1); } //--- displaying the account type Print("Account type: ",EnumToString(account_type)); //--- clarifying if we can trade on this account if(account.TradeAllowed()) Print("Trading on this account is allowed"); else Print("Trading on this account is forbidden: you may have entered using the Investor password"); //--- clarifying if we can use an Expert Advisor on this account if(account.TradeExpert()) Print("Automated trading on this account is allowed"); else Print("Automated trading using Expert Advisors and scripts on this account is forbidden"); //--- clarifying if the permissible number of orders has been set int orders_limit=account.LimitOrders(); if(orders_limit!=0)Print("Maximum permissible amount of active pending orders: ",orders_limit); //--- displaying company and server names Print(account.Company(),": server ",account.Server()); //--- displaying balance and current profit on the account in the end Print("Balance=",account.Balance()," Profit=",account.Profit()," Equity=",account.Equity()); Print(__FUNCTION__," completed"); //--- return(0); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- }
Come possiamo vedere dal codice sopra, molti dati utili possono essere ricevuti utilizzando la variabile account nella funzione OnInit(). È possibile aggiungere questo codice all’Expert Advisor per esaminare facilmente i log durante l'analisi del suo funzionamento.
I risultati di un Expert Advisor lanciato sul conto Automated Trading Championship 2012 sono mostrati di seguito.
Ricevere le Impostazioni del Simbolo on CSymbolInfo
Ora, abbiamo i dati sull’account ma abbiamo anche bisogno di conoscere le proprietà del simbolo che stiamo per scambiare prima di eseguire le operazioni necessarie. La classe CSymbolInfo con un gran numero di metodi è progettata per questi scopi. Mostreremo solo una piccola parte dei metodi nell'esempio seguente.
#include<Trade\SymbolInfo.mqh> //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- object for receiving symbol settings CSymbolInfo symbol_info; //--- set the name for the appropriate symbol symbol_info.Name(_Symbol); //--- receive current rates and display symbol_info.RefreshRates(); Print(symbol_info.Name()," (",symbol_info.Description(),")", " Bid=",symbol_info.Bid()," Ask=",symbol_info.Ask()); //--- receive minimum freeze levels for trade operations Print("StopsLevel=",symbol_info.StopsLevel()," pips, FreezeLevel=", symbol_info.FreezeLevel()," pips"); //--- receive the number of decimal places and point size Print("Digits=",symbol_info.Digits(), ", Point=",DoubleToString(symbol_info.Point(),symbol_info.Digits())); //--- spread info Print("SpreadFloat=",symbol_info.SpreadFloat(),", Spread(current)=", symbol_info.Spread()," pips"); //--- request order execution type for limitations Print("Limitations for trade operations: ",EnumToString(symbol_info.TradeMode()), " (",symbol_info.TradeModeDescription(),")"); //--- clarifying trades execution mode Print("Trades execution mode: ",EnumToString(symbol_info.TradeExecution()), " (",symbol_info.TradeExecutionDescription(),")"); //--- clarifying contracts price calculation method Print("Contract price calculation: ",EnumToString(symbol_info.TradeCalcMode()), " (",symbol_info.TradeCalcModeDescription(),")"); //--- sizes of contracts Print("Standard contract size: ",symbol_info.ContractSize(), " (",symbol_info.CurrencyBase(),")"); //--- minimum and maximum volumes in trade operations Print("Volume info: LotsMin=",symbol_info.LotsMin()," LotsMax=",symbol_info.LotsMax(), " LotsStep=",symbol_info.LotsStep()); //--- Print(__FUNCTION__," completed"); //--- return(0); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- }
Le proprietà EURUSD all'Automated Trading Championship sono mostrate di seguito. Ora, siamo pronti per eseguire operazioni di trading.
CTrade - Classe Conveniente per le Operazioni di Trading
Il trading in MQL5 viene eseguito solo da due funzioni: OrderSend() e OrderSendAsync(). In realtà, queste sono due implementazioni di una funzione. OrderSend() invia una richiesta di trading e attende il suo risultato di esecuzione, mentre OrderSendAsync() asincrono invia semplicemente una richiesta che consente all'applicazione di continuare il suo funzionamento senza attendere la risposta di un server di trading. Pertanto, è davvero facile fare trading in MQL5, poiché si utilizza una sola funzione per tutte le operazioni di trading.
Quindi, qual è la sfida? Entrambe le funzioni ricevono la struttura MqlTradeRequest contenente più di una dozzina di campi come primo parametro. Non tutti i campi devono essere necessariamente compilati. L'insieme di quelli necessari dipende da un tipo di operazioni di trading. Il valore errato o il campo vuoto che è necessario compilare comporterà un errore e la richiesta non verrà inviata ad un server. 5 di questi campi richiedono valori corretti da enumerazioni predefinite.
Un numero così elevato di campi è necessario per descrivere molte proprietà dell'ordine in una richiesta di trading. Gli ordini possono cambiare a seconda della politica di esecuzione, del tempo di scadenza e di alcuni altri parametri. Ma non devi imparare tutte queste sottigliezze. Basta usare la classe CTrade già pronta. Ecco come la classe può essere utilizzata nel tuo robot di trading:
#include<Trade\Trade.mqh> //--- object for performing trade operations CTrade trade; //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- set MagicNumber for your orders identification int MagicNumber=123456; trade.SetExpertMagicNumber(MagicNumber); //--- set available slippage in points when buying/selling int deviation=10; trade.SetDeviationInPoints(deviation); //--- order filling mode, the mode allowed by the server should be used trade.SetTypeFilling(ORDER_FILLING_RETURN); //--- logging mode: it would be better not to declare this method at all, the class will set the best mode on its own trade.LogLevel(1); //--- what function is to be used for trading: true - OrderSendAsync(), false - OrderSend() trade.SetAsyncMode(true); //--- return(0); }
Ora vediamo come CTrade aiuta nelle operazioni di trading.
Acquisto/vendita al prezzo corrente
Le strategie di trading spesso offrono la possibilità di acquistare o vendere al prezzo corrente in questo momento. In questo caso, CTrade chiede solo di specificare un volume di operazioni di trading necessario. Tutti gli altri parametri (prezzo aperto e nome del simbolo , livelli Stop Loss e Take Profit, commenti degli ordini) sono facoltativi.
//--- 1. example of buying at the current symbol if(!trade.Buy(0.1)) { //--- failure message Print("Buy() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("Buy() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Di default, CTrade utilizzerà il nome del simbolo del grafico su cui è stato lanciato se il nome del simbolo non è specificato. È conveniente per strategie semplici. Per le strategie multi-valuta, dovresti sempre specificare esplicitamente il simbolo per il quale verrà eseguita l'operazione di trading.
//--- 2. example of buying at the specified symbol if(!trade.Buy(0.1,"GBPUSD")) { //--- failure message Print("Buy() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("Buy() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Tutti i parametri dell'ordine possono essere specificati: Livelli di Stop Loss/Take Profit, prezzo aperto e commenti.
//--- 3. example of buying at the specified symbol with specified SL and TP double volume=0.1; // specify a trade operation volume string symbol="GBPUSD"; //specify the symbol, for which the operation is performed int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // point double bid=SymbolInfoDouble(symbol,SYMBOL_BID); // current price for closing LONG double SL=bid-1000*point; // unnormalized SL value SL=NormalizeDouble(SL,digits); // normalizing Stop Loss double TP=bid+1000*point; // unnormalized TP value TP=NormalizeDouble(TP,digits); // normalizing Take Profit //--- receive the current open price for LONG positions double open_price=SymbolInfoDouble(symbol,SYMBOL_ASK); string comment=StringFormat("Buy %s %G lots at %s, SL=%s TP=%s", symbol,volume, DoubleToString(open_price,digits), DoubleToString(SL,digits), DoubleToString(TP,digits)); if(!trade.Buy(volume,symbol,open_price,SL,TP,comment)) { //--- failure message Print("Buy() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("Buy() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Come abbiamo già detto, il Magic Number e lo slippage ammissibile sono stati impostati durante l'inizializzazione della copia di Ctrade. Pertanto, non sono richiesti. Tuttavia, possono anche essere impostati prima di ogni operazione di trading se necessario.
Effettuare un ordine limite
Per l'invio di un ordine limite viene utilizzato il metodo di classe BuyLimit() o SellLimit() appropriato. La versione abbreviata (quando sono specificati solo un prezzo open e un volume) sarà appropriata nella maggior parte dei casi. Il prezzo Open per Buy Limit dovrebbe essere inferiore al prezzo corrente, mentre dovrebbe essere più alto per Sell Limit. Questi ordini vengono utilizzati per entrare nel mercato al miglior prezzo e di solito sono più adatti per le strategie che si aspettano il rimbalzo del prezzo dalla linea di supporto. Il simbolo, al quale è stato lanciato un Expert Advisor, viene utilizzato in quel caso:
//--- 1. example of placing a Buy Limit pending order string symbol="GBPUSD"; // specify the symbol, at which the order is placed int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // point double ask=SymbolInfoDouble(symbol,SYMBOL_ASK); // current buy price double price=1000*point; // unnormalized open price price=NormalizeDouble(price,digits); // normalizing open price //--- everything is ready, sending a Buy Limit pending order to the server if(!trade.BuyLimit(0.1,price)) { //--- failure message Print("BuyLimit() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("BuyLimit() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
È, inoltre, possibile utilizzare una versione più dettagliata specificando tutti i parametri: Livelli SL/TP, tempo di scadenza, nome del simbolo e commenti all'ordine.
//--- 2. example of placing a Buy Limit pending order with all parameters double volume=0.1; string symbol="GBPUSD"; // specify the symbol, at which the order is placed int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // point double ask=SymbolInfoDouble(symbol,SYMBOL_ASK); // current buy price double price=1000*point; // unnormalized open price price=NormalizeDouble(price,digits); // normalizing open price int SL_pips=300; // Stop Loss in points int TP_pips=500; // Take Profit in points double SL=price-SL_pips*point; // unnormalized SL value SL=NormalizeDouble(SL,digits); // normalizing Stop Loss double TP=price+TP_pips*point; // unnormalized TP value TP=NormalizeDouble(TP,digits); // normalizing Take Profit datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1); string comment=StringFormat("Buy Limit %s %G lots at %s, SL=%s TP=%s", symbol,volume, DoubleToString(price,digits), DoubleToString(SL,digits), DoubleToString(TP,digits)); //--- everything is ready, sending a Buy Limit pending order to the server if(!trade.BuyLimit(volume,price,symbol,SL,TP,ORDER_TIME_GTC,expiration,comment)) { //--- failure message Print("BuyLimit() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("BuyLimit() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Il tuo compito nella seconda versione è quello di indicare correttamente i livelli SL e TP. Va notato che il livello di Take Profit deve essere superiore al prezzo Open al momento dell'acquisto, mentre il livello di Stop Loss deve essere inferiore al prezzo Open. La situazione inversa è per gli ordini Sell Limit. Puoi facilmente conoscere il tuo errore quando esegui il test di un Expert Advisor su dati storici. In questi casi la classe CTrade visualizza automaticamente i messaggi (a meno che tu non abbia chiamato la funzione LogLevel).
Effettuare un ordine stop
Metodi BuyStop() e SellStop() simile vengono utilizzati per inviare un ordine stop. Il prezzo di apertura per Buy Stop dovrebbe essere superiore al prezzo corrente, mentre dovrebbe essere inferiore per Sell Stop. Gli ordini stop vengono utilizzati nelle strategie che entrano nel mercato durante un breakout a livello di resistenza, nonché per ridurre le perdite. Versione semplice:
//--- 1. example of placing a Buy Stop pending order string symbol="USDJPY"; // specify the symbol, at which the order is placed int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // point double ask=SymbolInfoDouble(symbol,SYMBOL_ASK); // current buy price double price=1000*point; // unnormalized open price price=NormalizeDouble(price,digits); // normalizing open price //--- everything is ready, sending a Buy Stop pending order to the server if(!trade.BuyStop(0.1,price)) { //--- failure message Print("BuyStop() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("BuyStop() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Una versione più dettagliata quando è necessario specificare la quantità massima di parametri per l’ordine in sospeso Buy Stop :
//--- 2. example of placing a Buy Stop pending order with all parameters double volume=0.1; string symbol="USDJPY"; // specify the symbol, at which the order is placed int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places double point=SymbolInfoDouble(symbol,SYMBOL_POINT); // point double ask=SymbolInfoDouble(symbol,SYMBOL_ASK); // current buy price double price=1000*point; // unnormalized open price price=NormalizeDouble(price,digits); // normalizing open price int SL_pips=300; // Stop Loss in points int TP_pips=500; // Take Profit in points double SL=price-SL_pips*point; // unnormalized SL value SL=NormalizeDouble(SL,digits); // normalizing Stop Loss double TP=price+TP_pips*point; // unnormalized TP value TP=NormalizeDouble(TP,digits); // normalizing Take Profit datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1); string comment=StringFormat("Buy Stop %s %G lots at %s, SL=%s TP=%s", symbol,volume, DoubleToString(price,digits), DoubleToString(SL,digits), DoubleToString(TP,digits)); //--- everything is ready, sending a Buy Stop pending order to the server if(!trade.BuyStop(volume,price,symbol,SL,TP,ORDER_TIME_GTC,expiration,comment)) { //--- failure message Print("BuyStop() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("BuyStop() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Il metodo di classe CTrade appropriato viene utilizzato per inviare l'ordine Sell Stop. Specificare correttamente i prezzi è di fondamentale importanza qui.
Lavorare con le posizioni
Puoi utilizzare i metodi di apertura delle posizioni invece di quelli Buy() e Sell(), ma dovrai specificare maggiori dettagli in questo caso:
//--- number of decimal places int digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); //--- point value double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); //--- receiving a buy price double price=SymbolInfoDouble(_Symbol,SYMBOL_ASK); //--- calculate and normalize SL and TP levels double SL=NormalizeDouble(price-1000*point,digits); double TP=NormalizeDouble(price+1000*point,digits); //--- filling comments string comment="Buy "+_Symbol+" 0.1 at "+DoubleToString(price,digits); //--- everything is ready, trying to open a buy position if(!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,0.1,price,SL,TP,comment)) { //--- failure message Print("PositionOpen() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("PositionOpen() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
È necessario specificare solo un nome di simbolo, il resto verrà fatto dalla classe CTrade.
//--- closing a position at the current symbol if(!trade.PositionClose(_Symbol)) { //--- failure message Print("PositionClose() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("PositionClose() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Sono disponibili solo i livelli Stop Loss e Take Profit per modificare una posizione aperta. Questo viene fatto usando il metodo PositionModify()
//--- number of decimal places int digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); //--- point value double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); //--- receiving the current Bid price double price=SymbolInfoDouble(_Symbol,SYMBOL_BID); //--- calculate and normalize SL and TP levels double SL=NormalizeDouble(price-1000*point,digits); double TP=NormalizeDouble(price+1000*point,digits); //--- everything is ready, trying to modify the buy position if(!trade.PositionModify(_Symbol,SL,TP)) { //--- failure message Print("Метод PositionModify() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("PositionModify() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Modificare ecancellare un ordine
Il metodoOrderModify() è stato implementato nella classe CTrade per modificare i parametri dell'ordine in sospeso. Tutti i parametri richiesti devono essere sottoposti a questo metodo.
//--- this is a sample order ticket, it should be received ulong ticket=1234556; //--- this is a sample symbol, it should be received string symbol="EURUSD"; //--- number of decimal places int digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); //--- point value double point=SymbolInfoDouble(symbol,SYMBOL_POINT); //--- receiving a buy price double price=SymbolInfoDouble(symbol,SYMBOL_ASK); //--- calculate and normalize SL and TP levels //--- they should be calculated based on the order type double SL=NormalizeDouble(price-1000*point,digits); double TP=NormalizeDouble(price+1000*point,digits); //--- setting one day as a lifetime datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1); //--- everything is ready, trying to modify the order if(!trade.OrderModify(ticket,price,SL,TP,ORDER_TIME_GTC,expiration)) { //--- failure message Print("OrderModify() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("OrderModify() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
Dovresti ricevere il ticket dell'ordine che dovrebbe essere cambiato. I livelli corretti di Stop Loss e Take Profit devono essere specificati a seconda del tipo. Inoltre, il nuovo prezzo open dovrebbe anche essere corretto rispetto al prezzo corrente.
Dovresti conoscere un ticket di un ordine per eliminarlo:
//--- this is a sample order ticket, it should be received ulong ticket=1234556; //--- everyrging is ready, trying to modify a buy position if(!trade.OrderDelete(ticket)) { //--- failure message Print("OrderDelete() method failed. Return code=",trade.ResultRetcode(), ". Code description: ",trade.ResultRetcodeDescription()); } else { Print("OrderDelete() method executed successfully. Return code=",trade.ResultRetcode(), " (",trade.ResultRetcodeDescription(),")"); }
La classe contiene anche il metodo multiuso OrderOpen() che può impostare ordini in sospeso di qualsiasi tipo. A differenza dei metodi specializzati BuyLimit, BuyStop, SellLimit e SellStop, richiede di specificare parametri più essenziali. Forse, lo troverai più conveniente.
Cos'Altro Dovremmo Risolvere?
Quindi, abbiamo risposto a due domande su tre. Hai scelto il simbolo per la tua strategia e ti abbiamo mostrato come codificare facilmente le operazioni di acquisto e vendita, nonché gli ordini in sospeso in un robot di trading. Ma la sezione Trade Classes ha alcuni strumenti più utili per gli sviluppatori MQL5:
- COrderInfo - per lavorare con gli ordini;
- CHistoryOrderInfo - per lavorare con gli ordini eseguiti nella cronologia di trading;
- CPositionInfo - per lavorare con le posizioni;
- CDealInfo - per lavorare con le operazioni;
- CTerminalInfo - per ricevere dati sul terminale (questo è molto interessante).
Con queste classi, puoi concentrare la tua attenzione sul lato trading della tua strategia riducendo al minimo tutti i problemi tecnici. Inoltre, la classe CTrade può essere utilizzata per esaminare le richieste di trading. Dopo un po’ di pratica, sarai in grado di usarlo per creare le tue classi personalizzate con le logiche necessarie per gestire i risultati di esecuzione delle richieste di trading.
L'ultima domanda è come ricevere i segnali di trading e come codificarli in MQL5. La maggior parte dei nuovi arrivati nel trading in algo inizia dallo studio di semplici sistemi di trading standard, ad esempio quelli basati sull'incrocio delle medie mobili. Per fare questo, dovresti prima imparare a lavorare con gli indicatori tecnici creandoli e utilizzandoli nel tuo robot di trading.
Ti consigliamo di leggere gli articoli delle sezioni Indicatori ed Examples->Indicators a partire dalle prime. Ciò ti consentirà di passare dalle questioni più semplici a quelle più complesse. Se vuoi ricevere rapidamente un'idea su come utilizzare gli indicatori, vedi MQL5 per i Principianti: Guida all'Utilizzo degli Indicatori Tecnici negli Expert Advisor.
Semplifica le Cose Complicate
In ogni impresa, le prime difficoltà si trasformano gradualmente nelle questioni più semplici che devi affrontare. I metodi di sviluppo dei robot di trading offerti qui sono pensati principalmente per i nuovi arrivati, anche se molti sviluppatori esperti possono anche trovare qualcosa di nuovo e utile.
Il linguaggio MQL5 offre non solo opportunità illimitate per il trading di algo, ma consente anche a tutti di implementarle nel modo più semplice e veloce. Usa le classi di trading della Libreria Standard per risparmiare tempo per cose più importanti, ad esempio per cercare la risposta all'eterna domanda di tutti i trader: cos'è una tendenza e come può essere trovata in tempo reale.
Presto vedrai che sviluppare un robot di trading in MQL5 è molto più facile che imparare una lingua straniera o seguire una tendenza!
Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/481
Strategie d'Ordine. Expert Advisor Multiuso
Tuffo veloce in MQL5
L'Istogramma dei Prezzi (Market Profile) e la sua implementazione in MQL5
Come Creare un Robot di Trading in Pochissimo Tempo
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso