Wie man im MT5 mit OrderSend korrekt arbeitet - Seite 11
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
Nicht zwei, sondern eine :)
TRADE_TRANSACTION_REQUEST wird benötigt, wenn Sie OrderSendAsymc verwenden, um ein Auftragsticket zu erhalten.
Was ist denn da los? Woher wissen Sie, ob ich speziell OrderSendAsync() verwende?
Und ich kann es nicht verwenden, um z.B. den Expert Advisor zu überprüfen, der eine Handelsanfrage gesendet hat? Oder zum Beispiel, um das Ticket der Position zu überprüfen, von der aus der letzte Handel ausgeführt wurde?
Schließlich kann ich dieses Ereignis verwenden, um den Preis zu überprüfen, zu dem die Transaktion durchgeführt wurde (obwohl ich zustimme, dass die Überprüfung des Preises in diesem Ereignis nur bei asynchronem Handel sinnvoll ist).
Wenn ich also asynchrones Senden von Aufträgen verwende, ist der Code dann korrekt?
Was ist also falsch daran? Woher wissen Sie, dass ich vielleicht OrderSendAsync() verwende?
Und ich kann sie nicht verwenden, um zum Beispiel den Stempel des Expert Advisors zu überprüfen, der eine Handelsanfrage gesendet hat? Oder zum Beispiel, um das Ticket der Position zu überprüfen, von der aus der letzte Handel ausgeführt wurde?
Schließlich kann ich dieses Ereignis verwenden, um den Preis zu überprüfen, zu dem die Transaktion durchgeführt wurde (obwohl ich zustimme, dass die Überprüfung des Preises in diesem Ereignis nur bei asynchronem Handel sinnvoll ist).
Wenn ich also asynchrones Senden von Aufträgen verwende, ist der Code korrekt?
Das Thema heißt
"Wie man richtig mit OrderSend arbeitet".
Diese Funktion (so wie sie von den Entwicklern konzipiert wurde) sollte vollständig synchron sein, d.h. wenn Sie eine Bestellung senden und wenn Sie ein Ticket erhalten,
mit der Bestellung alles in Ordnung ist. Nun funktioniert diese Funktion aber nicht ganz korrekt, so dass Sie nach Erhalt eines Tickets für eine Bestellung
in OnTradeTransaction eine Bestätigung erhalten, dass alles in Ordnung ist.
D.h. die Daten zu diesem Auftrag sind im Terminal vollständig synchronisiert.
// Expert TradeTransaction function |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
switch(trans.type)
{
case TRADE_TRANSACTION_ORDER_UPDATE:
switch(trans.order_state)
{
case ORDER_STATE_PLACED:
if(order_ticket==trans.order)
{
Print(__FUNCTION__," Order plased done. Ticket = ",trans.order);
if(order_ticket>0)
{
if(OrderSelect(order_ticket))
{
//Данные по ордеру синхронизированы
}
else
{
Print(__FUNCTION__," Order not select! Ticket = ",trans.order);
}
}
else
{
Print(__FUNCTION__," Wrong order ticket = ",trans.order);
}
}
break;
}
break;
}
}
Das Thema heißt
"Wie man richtig mit OrderSend arbeitet".
Diese Funktion (so wie sie von den Entwicklern konzipiert wurde) sollte vollständig synchron sein, d.h. wenn Sie eine Bestellung senden und wenn Sie ein Ticket erhalten,
mit der Bestellung alles in Ordnung ist. Nun funktioniert diese Funktion aber nicht ganz korrekt, so dass Sie nach Erhalt eines Tickets für eine Bestellung
in OnTradeTransaction eine Bestätigung erhalten, dass alles in Ordnung ist.
Das heißt, die Daten für diesen Auftrag sind im Terminal vollständig synchronisiert.
// Expert TradeTransaction function |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
switch(trans.type)
{
case TRADE_TRANSACTION_ORDER_UPDATE:
switch(trans.order_state)
{
case ORDER_STATE_PLACED:
if(order_ticket==trans.order)
{
Print(__FUNCTION__," Order plased done. Ticket = ",trans.order);
if(order_ticket>0)
{
if(OrderSelect(order_ticket))
{
//Данные по ордеру синхронизированы
}
else
{
Print(__FUNCTION__," Order not select! Ticket = ",trans.order);
}
}
else
{
Print(__FUNCTION__," Wrong order ticket = ",trans.order);
}
}
break;
}
break;
}
}
Großartig! Ich weiß, wie es funktioniert. Ich verwende jedoch asynchrones Senden von Aufträgen. Ich habe ein anderes Problem: Das Ereignis REQUEST (im Sinne des Abschlusses der Transaktionssummen) für dieselbe Transaktion kam zweimal.
Sie verstehen einfach nicht ganz, wie die Nachrichten in OnTradeTransaction behandelt werden sollen, wenn Sie OrderSEndAsync setzen
Nehmen Sie diesen EA auf und sehen Sie, wie er funktioniert
Sie verstehen einfach nicht ganz, wie OnTradeTransaction-Nachrichten bei der Platzierung von OrderSEndAsync behandelt werden sollten
Nehmen Sie den Expert Advisor auf und sehen Sie, wie er funktioniert
Das ist es, was ich Sie frage, wie TradeTransactions korrekt gehandhabt werden sollten.
Ich frage Sie also, wie TradeTransactions korrekt gehandhabt werden sollten.
Die Reihenfolge für OrderSendAsync ist wie folgt:
Wenn Sie eine Bestellung mit dem OrderSendAsync-Befehl senden, erhalten Sie bei erfolgreichem Versand order_id
{
double price=SymbolInfoDouble(Symbol(),SYMBOL_SESSION_PRICE_LIMIT_MAX);
MqlTradeRequest request={0};
MqlTradeResult result={0};
order_ticket=0;
order_id=0;
request.action = TRADE_ACTION_PENDING;
request.magic = 9876543210;
request.symbol = Symbol();
request.volume = 1;
request.price = price;
request.type=ORDER_TYPE_SELL_LIMIT;
request.comment="Async mode";
request.type_filling=ORDER_FILLING_RETURN;
request.type_time=ORDER_TIME_DAY;
if(OrderSendAsync(request,result))
{
if((result.retcode==TRADE_RETCODE_PLACED) || (result.retcode==TRADE_RETCODE_DONE))
{
if(result.request_id>0)
{
order_id=result.request_id;
Print(__FUNCTION__," Order sent in async mode");
return(true);
}
else
{
Print(__FUNCTION__," Error order sent in async mode! Retcode = ",result.retcode);
}
}
else
{
Print(__FUNCTION__," Error order sent in async mode! Retcode = ",result.retcode);
}
}
else
{
Print(__FUNCTION__," Order not sent in async mode.");
}
return(false);
}
Dann erhalten wir alle anderen Daten in OnTradeTransactions
1. Bestellschein erhalten
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
switch(trans.type)
{
case TRADE_TRANSACTION_REQUEST:
if((order_id>0) && (order_id==result.request_id))
{
order_id=0;
order_ticket=result.order;
Print(__FUNCTION__," Order get ticket done. Ticket = ",result.order);
}
break;
}
}
2. Wenn Sie Markt- oder Limitaufträge (nicht schwebende Aufträge) verwenden, d.h. Aufträge, die sofort ausgeführt werden
oder abgelehnt wird, ist es notwendig, TRADE_TRANSACTION_HISTORY_ADD zu überwachen, da in jedem Fall 3.
Solche Aufträge werden in die Historie aufgenommen.
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
switch(trans.type)
{
case TRADE_TRANSACTION_HISTORY_ADD:
if(order_ticket==trans.order)
{
//Берем данные из истории
}
break;
}
}
Wenn Sie schwebende Aufträge verwenden (die in Teilen ausgeführt werden können), sollten Sie Folgendes überwachen
Es gibt drei Ereignisse TRADE_TRANSACTION_ORDER_UPDATE, TRADE_TRANSACTION_HISTORY_ADD, TRADE_TRANSACTION_DEAL_ADD.
TRADE_TRANSACTION_ORDER_UPDATE - dient dazu, die Information zu erhalten, dass der Auftrag eingestellt (geändert) wurde
TRADE_TRANSACTION_DEAL_ADD - Abruf der Information, dass ein Geschäft abgeschlossen wurde
TRADE_TRANSACTION_HISTORY_ADD - der Auftrag ist nicht im Handelssystem vorhanden; wir können die Daten des Auftrags einsehen
Das ist die ganze "Weisheit"
Hinzugefügt
Die Interaktion zwischenOrderSendAsync undOnTradeTransactionfunktioniert ohne Probleme.
und auf dem Devisenmarkt (real)
Hinzugefügt
OrderSendAsync undOnTradeTransactionfunktionieren gut, ich habe es auf FOREX (Demo) überprüft
Beide auf FOREX (real)
Ich danke Ihnen! Jetzt weiß ich, wie man die Funktion OnTradeTransaction() verwendet, oder gibt es noch andere Geheimnisse?
Wie kann ich es ohne Vorbehalte tun, wenn das TradeTransaction()-Ereignis verloren gehen kann?
Ich danke Ihnen! Jetzt weiß ich, wie ich OnTradeTransaction() verwenden kann, oder gibt es noch andere Geheimnisse?
Wie kann es keine Vorbehalte geben, wenn das Ereignis TradeTransaction() verloren gehen kann?
Es gibt keine Geheimnisse mehr.
Sie kann verloren gehen (aber das ist in 4-5 Monaten 3-4 Mal passiert, und zwar in Zeiten starker Marktaktivität),
Eine Versicherung wäre also keine schlechte Sache.
Und hier ein konkretes Beispiel für eine Auftragsprüfung
Terminal-Protokoll:
2017.01.05 11:46:02.895 Trades 'xxxxx': accepted buy limit 1.00 PLT-6.17 at 952.3
2017.01.05 11:46:02.896 Trades 'xxxxx': buy limit 1.00 PLT-6.17 at 952.3 placed for execution in 1223.187 ms
Expert Advisor Log:
Die Bestellung wurde gesendet am2017.01.05 11:46:01.673
Keine Antwort vom Server seit mehr als 1 Sekunde, Auftrag wurde geprüft.
Im normalen Modus erfolgt die Antwort in 7-10 msec.
Beantwortung der Frage"Wie arbeitet man richtig in MT5 mit OrderSend"
Darauf gibt es eine einfache Antwort.
Bis die Entwickler das Problem behoben haben, wird
ulong order_ticket; //Тикет ордера
//---
if(OrderSend(request,result))
{
if(result.retcode==TRADE_RETCODE_DONE)
{
pre_ticket=result.order;
}
}
//----------------------------------------------------------------+
//| TradeTransaction function |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
switch(trans.type)
{
case TRADE_TRANSACTION_ORDER_UPDATE:
if((pre_ticket>0) && (trans.order==pre_ticket))
{
switch(trans.order_state)
{
case ORDER_STATE_PLACED:
order_ticket = pre_ticket;
break;
}
}
break;
}
}
Wenn sie das tun, dann
//---
if(OrderSend(request,result))
{
if(result.retcode==TRADE_RETCODE_DONE)
{
order_ticket=result.order;
}
}