MQL5 Handels-Toolkit (Teil 8): Implementierung und Verwendung der EX5-Bibliothek History Manager in Ihrer Codebasis
22
0
Einführung
In früheren Artikeln habe ich Sie durch die Entwicklung einer robusten und umfassenden EX5-Bibliothek History Management geführt, die die Interaktion mit Handelsverläufen im MetaTrader 5 optimieren soll. Mit dieser leistungsstarken Bibliothek können Sie mühelos alle Arten von Handelsverläufen scannen, abrufen, sortieren, kategorisieren und filtern - egal, ob es sich um geschlossene Positionen, schwebende Aufträge oder Handelsverläufe handelt - direkt von Ihrem MetaTrader 5-Konto aus. Dieser Artikel baut auf dieser Grundlage auf und zeigt Ihnen, wie Sie die History Manager-Bibliothek effizient in Ihre MQL5-Projekte integrieren können.
Ich werde eine detaillierte Aufschlüsselung der in der EX5-Bibliothek verfügbaren Funktionen mit klaren Erklärungen und praktischen Beispielen geben. Diese realen Anwendungsfälle helfen Ihnen nicht nur, die Funktionsweise der einzelnen Funktionen zu verstehen, sondern zeigen Ihnen auch, wie Sie sie in Ihren Handelsstrategien oder Analysetools einsetzen können. Egal, ob Sie ein Anfänger sind, der seine Programmierkenntnisse verbessern möchte, oder ein erfahrener Entwickler, der seine Arbeitsabläufe optimieren möchte, dieses Handbuch vermittelt Ihnen das Wissen und die Werkzeuge, um das volle Potenzial der History Manager-Bibliothek auszuschöpfen. Am Ende dieses Artikels werden Sie in der Lage sein, diese vielseitige Bibliothek mit Zuversicht zu implementieren und ihre Fähigkeiten zu nutzen, um Handelsverläufe effizienter als je zuvor zu verwalten.
Vorteile der Verwendung des History Managers in MQL5
Nachfolgend finden Sie die wichtigsten Vorteile der Integration des History Managers in Ihre MQL5-Projekte:
- Mühelose Datenabfrage: Die Bibliothek bietet intuitive Funktionen zum Abrufen von Handelsverlaufsdaten wie Handelsgeschäften, Aufträgen, Positionen und schwebenden Aufträgen mit minimalem Code. Dadurch entfällt die Notwendigkeit komplexer und sich wiederholender Kodierungen.
- Vereinheitlichte Schnittstelle: Alle Daten der Handelshistorie sind über eine einzige, einheitliche Schnittstelle zugänglich, was die Verwaltung und Analyse verschiedener Arten von Handelsaktivitäten erleichtert.
- Zeitsparende Funktionen: Mit einzeiligen Funktionsaufrufen können Sie schnell auf wichtige Handelsdaten zugreifen, was die Entwicklungszeit verkürzt und es Ihnen ermöglicht, sich auf die Strategieumsetzung zu konzentrieren.
- Automatisierte Datenverarbeitung: Die Bibliothek automatisiert den Abruf, die Sortierung und die Filterung von Handelsverläufen, wodurch die Arbeitsabläufe rationalisiert und die Gesamteffizienz verbessert werden.
- Fehlerfreie Datenverarbeitung: Die Bibliothek gewährleistet den genauen Abruf von Daten aus dem Handelsverlauf und minimiert das Risiko von Fehlern, die bei manueller Kodierung auftreten können.
- Umfassende Datenabdeckung: Von geschlossenen Positionen bis hin zu schwebenden Aufträgen bietet die Bibliothek Zugriff auf alle Arten von Handelsverläufen und stellt sicher, dass keine Daten übersehen werden.
- Detaillierte Einblicke: Funktionen wie GetLastClosedPositionData(), GetLastFilledPendingOrderData() und GetLastClosedProfitablePositionData() und viele andere liefern detaillierte Angaben zu den Handelsgeschäften, die eine gründlichere Analyse und bessere Entscheidungsfindung ermöglichen.
- Anpassbare Filter: Sie können Handelsverläufe nach Symbolen, magischen Zahlen oder Zeitspannen filtern, was eine gezielte, auf Ihre Bedürfnisse zugeschnittene Analyse ermöglicht.
- Einfache Implementierung: Die Bibliothek ist so konzipiert, dass sie sich nahtlos in bestehende MQL5-Projekte integrieren lässt und nur eine minimale Einrichtung und Konfiguration erfordert.
- Skalierbarkeit: Egal, ob Sie an einem kleinen Skript oder einem großen Handelssystem arbeiten, der History Manager lässt sich mühelos an Ihre Anforderungen anpassen.
- Anpassungsfähig an Ihre Bedürfnisse: Der modulare Aufbau der Bibliothek ermöglicht es Ihnen, nur die Funktionen zu verwenden, die Sie benötigen, und macht sie so äußerst anpassungsfähig an verschiedene Handelsstile und -strategien.
- Erweiterbare Funktionalität: Entwickler können auf den vorhandenen Funktionen der Bibliothek aufbauen, um individuelle Lösungen für spezielle Handelsanforderungen zu erstellen.
- Vorgefertigte Lösungen: Indem Sie die vorgefertigten Funktionen der Bibliothek nutzen, können Sie den Zeit- und Kostenaufwand für die Entwicklung nutzerdefinierter Tools zur Verwaltung der Handelshistorie erheblich reduzieren.
- Offen für alle Fähigkeitsstufen: Egal, ob Sie ein Anfänger oder ein erfahrener Entwickler sind, das einfache Design der Bibliothek macht sie für Nutzer aller Kenntnisstufen zugänglich.
- Datengestützte Entscheidungen: Der Zugang zu umfassenden Handelshistorien ermöglicht es Ihnen, fundierte Entscheidungen bei der Entwicklung oder Verfeinerung von Handelsstrategien zu treffen.
- Historische Rückentests: Nutzen Sie die Bibliothek, um historische Handelsdaten für Backtests abzurufen und so sicherzustellen, dass Ihre Strategien robust und zuverlässig sind.
- Sauberer und lesbarer Code: Die Funktionen der Bibliothek sind so konzipiert, dass sie sauberen, lesbaren Code erzeugen, der die Wartung und Aktualisierung Ihrer Projekte erleichtert.
Importieren und Einrichten der EX5-Bibliothek History Manager
Bevor Sie die Funktionen der EX5-Bibliothek History Manager nutzen können, müssen Sie die Bibliothek ordnungsgemäß in Ihr MQL5-Projekt importieren und einrichten. In diesem Abschnitt werden Sie Schritt für Schritt durch den Prozess geführt, um eine reibungslose Einrichtung zu gewährleisten.
Um die Bibliotheksdatei HistoryManager.ex5 in Ihren MQL5-Projekten zu verwenden, muss sie heruntergeladen und in das richtige Verzeichnis in Ihrem MetaTrader 5-Installationsordner platziert werden. Starten Sie MetaEditor von Ihrem MetaTrader 5-Terminal aus, indem Sie zu Tools > MetaQuotes Language Editor navigieren oder F4 drücken, und folgen Sie den nachstehenden Schritten:
- Schritt 1. Erstellen Sie die erforderlichen Verzeichnisse:
Erstellen Sie im Ordner „Libraries“, der sich im MQL5-Stammverzeichnis befindet, die folgenden Unterverzeichnisse, sofern sie noch nicht vorhanden sind: „\Wanateki\Toolkit\HistoryManager“.
Der vollständige Pfad in Ihrem MQL5-Installationsordner sollte wie folgt aussehen: „MQL5\Libraries\Wanateki\Toolkit\HistoryManager“.
- Schritt 2. Laden Sie die Binärdatei HistoryManager.ex5 herunter:
Scrollen Sie zum Ende dieses Artikels, suchen Sie die angehängte Datei HistoryManager.ex5 und laden Sie sie herunter. Legen Sie die Datei im Ordner HistoryManager ab, den Sie in Schritt 1 erstellt haben.
Die Verzeichnisstruktur Ihrer Bibliotheken sollte nun wie in der folgenden Abbildung aussehen:
- Schritt 3. Erstellen Sie die Header Library Datei:
1. Starten Sie in MetaEditor IDE den MQL-Assistenten über die Schaltfläche Neu im Menü.
2. Wählen Sie die Option Include (*.mqh) und klicken Sie auf Next (Weiter).
3. Suchen Sie im Fenster der Allgemeinen Eigenschaften der Include-Datei das Eingabefeld Name: Löschen Sie den gesamten Text und geben Sie den folgenden Pfad ein, um das Verzeichnis und den Namen für die Include-Datei anzugeben: „Include\Wanateki\Toolkit\HistoryManager\HistoryManager.mqh“
4. Klicken Sie auf die Schaltfläche Fertig stellen, um die Header-Datei der Bibliothek zu erstellen.
Kodierung der Header-Datei von History Manager (HistoryManager.mqh)
Nachdem wir nun erfolgreich eine leere Include-Datei für den Header der Bibliothek HistoryManager.mqh erstellt haben, besteht der nächste Schritt darin, sie mit den notwendigen Komponenten zu füllen, die ihre Funktionalität definieren. Dazu gehören das Hinzufügen von Datenstrukturen zur effizienten Verwaltung und Speicherung von Informationen, das Einfügen von Makroanweisungen zur Vereinfachung sich wiederholender Aufgaben und zur Verbesserung der Lesbarkeit des Codes sowie das Importieren und Deklarieren der Bibliotheksfunktionen, die als zentrale Schnittstellen für die Interaktion mit den Funktionen von HistoryManager.ex5 dienen.
Unter den Direktiven #property deklarieren wir zunächst die Datenstrukturen DealData, OrderData, PositionData und PendingOrderData im globalen Bereich. Diese Strukturen werden für die Speicherung verschiedener Eigenschaften des Handelsverlaufs zuständig sein und von jedem Teil unserer Codebasis aus zugänglich sein.
struct DealData { // Add all the DealData members here } struct OrderData { // Add all the OrderData members here } struct PositionData { // Add all the PositionData members here } struct PendingOrderData { // Add all the PendingOrderData members here }
Als Nächstes werden wir mehrere Konstanten oder Makros definieren, die wichtige Zeitspannen in Sekunden darstellen. Dazu gehören NOW, ONE_DAY, ONE_WEEK, ONE_MONTH, ONE_YEAR, EPOCH, TODAY, THIS_WEEK, THIS_MONTH und THIS_YEAR , die zeitbezogene Berechnungen vereinfachen und die Lesbarkeit des Codes verbessern werden.
#define NOW datetime(TimeCurrent()) #define ONE_DAY datetime(TimeCurrent() - PeriodSeconds(PERIOD_D1)) #define ONE_WEEK datetime(TimeCurrent() - PeriodSeconds(PERIOD_W1)) #define ONE_MONTH datetime(TimeCurrent() - PeriodSeconds(PERIOD_MN1)) #define ONE_YEAR datetime(TimeCurrent() - (PeriodSeconds(PERIOD_MN1) * 12)) #define EPOCH 0 // 1st Jan 1970 //-- #define TODAY 12 #define THIS_WEEK 13 #define THIS_MONTH 14 #define THIS_YEAR 15
Wir werden auch das String-Makro ALL_SYMBOLS erstellen, um eine leere Zeichenkette zu speichern. Dies dient als Signal, um anzuzeigen, dass wir den angegebenen Verlauf für alle Symbole verarbeiten wollen. Zusätzlich werden wir die Ganzzahlmakros ALL_POSITIONS, ALL_ORDERS und ALL_DEALS definieren. Damit können wir die Arten von Aufträgen, Deals und Positionsverläufen angeben, die wir verarbeiten möchten.
#define ALL_SYMBOLS "" #define ALL_POSITIONS 1110 #define ALL_ORDERS 1111 #define ALL_DEALS 1112
Nachdem wir nun alle notwendigen Datenstrukturen erstellt und die wesentlichen Präprozessoranweisungen oder Makros definiert haben, ist es an der Zeit, die Bibliothek HistoryManager.ex5 zu importieren. Dazu verwenden wir die Direktive #import, gefolgt von dem Ordnerpfad, in dem sich die EX5-Bibliothek befindet.
#import "Wanateki/Toolkit/HistoryManager/HistoryManager.ex5"
Nach der Direktive #import fügen wir die Deklarationen der Bibliotheksfunktionen hinzu und schließen mit der abschließenden Direktive #import als letzte Zeile unserer Header-Datei HistoryManager.mqh.
#import "Wanateki/Toolkit/HistoryManager/HistoryManager.ex5" //-- void PrintDealsHistory(datetime fromDateTime, datetime toDateTime); void PrintOrdersHistory(datetime fromDateTime, datetime toDateTime); void PrintPositionsHistory(datetime fromDateTime, datetime toDateTime); void PrintPendingOrdersHistory(datetime fromDateTime, datetime toDateTime); //-- bool GetDealsData(DealData &dealsData[], datetime fromDateTime, datetime toDateTime, string symbol, ulong magic); bool GetOrdersData(OrderData &ordersData[], datetime fromDateTime, datetime toDateTime, string symbol, ulong magic); bool GetPositionsData(PositionData &positionsData[], datetime fromDateTime, datetime toDateTime, string symbol, ulong magic); bool GetPendingOrdersData(PendingOrderData &pendingOrdersData[], datetime fromDateTime, datetime toDateTime, string symbol, ulong magic); //-- // Add all the other function declarations here... #import
Nachfolgend sind die wesentlichen Codesegmente aufgeführt, die die Include-Datei HistoryManager.mqh bilden. Diese Header-Datei enthält alle notwendigen Ressourcen für den Import und die Integration der EX5-Bibliothek History Manager in Ihre MQL5-Projekte. Indem wir sie am Anfang unsere Quelldatei einfügen, erhalten wir Zugriff auf alle Datenstrukturen und Bibliotheksfunktionen und können sie sofort verwenden. Die vollständige Quelldatei HistoryManager.mqh ist ebenfalls am Ende dieses Artikels zum Herunterladen beigefügt.
struct DealData { ulong ticket; ulong magic; ENUM_DEAL_ENTRY entry; ENUM_DEAL_TYPE type; ENUM_DEAL_REASON reason; ulong positionId; ulong order; string symbol; string comment; double volume; double price; datetime time; double tpPrice; double slPrice; double commission; double swap; double profit; }; //-- struct OrderData { datetime timeSetup; datetime timeDone; datetime expirationTime; ulong ticket; ulong magic; ENUM_ORDER_REASON reason; ENUM_ORDER_TYPE type; ENUM_ORDER_TYPE_FILLING typeFilling; ENUM_ORDER_STATE state; ENUM_ORDER_TYPE_TIME typeTime; ulong positionId; ulong positionById; string symbol; string comment; double volumeInitial; double priceOpen; double priceStopLimit; double tpPrice; double slPrice; }; //-- struct PositionData { ENUM_POSITION_TYPE type; ulong ticket; ENUM_ORDER_TYPE initiatingOrderType; ulong positionId; bool initiatedByPendingOrder; ulong openingOrderTicket; ulong openingDealTicket; ulong closingDealTicket; string symbol; double volume; double openPrice; double closePrice; datetime openTime; datetime closeTime; long duration; double commission; double swap; double profit; double tpPrice; double slPrice; int tpPips; int slPips; int pipProfit; double netProfit; ulong magic; string comment; }; //-- struct PendingOrderData { string symbol; ENUM_ORDER_TYPE type; ENUM_ORDER_STATE state; double priceOpen; double tpPrice; double slPrice; int tpPips; int slPips; ulong positionId; ulong ticket; datetime timeSetup; datetime expirationTime; datetime timeDone; ENUM_ORDER_TYPE_TIME typeTime; ulong magic; ENUM_ORDER_REASON reason; ENUM_ORDER_TYPE_FILLING typeFilling; string comment; double volumeInitial; double priceStopLimit; }; //-- #define NOW datetime(TimeCurrent()) #define ONE_DAY datetime(TimeCurrent() - PeriodSeconds(PERIOD_D1)) #define ONE_WEEK datetime(TimeCurrent() - PeriodSeconds(PERIOD_W1)) #define ONE_MONTH datetime(TimeCurrent() - PeriodSeconds(PERIOD_MN1)) #define ONE_YEAR datetime(TimeCurrent() - (PeriodSeconds(PERIOD_MN1) * 12)) #define EPOCH 0 // 1st Jan 1970 //-- #define TODAY 12 #define THIS_WEEK 13 #define THIS_MONTH 14 #define THIS_YEAR 15 //-- #define ALL_SYMBOLS "" #define ALL_POSITIONS 1110 #define ALL_ORDERS 1111 #define ALL_DEALS 1112 //-- #import "Wanateki/Toolkit/HistoryManager/HistoryManager.ex5" //-- void PrintDealsHistory(datetime fromDateTime, datetime toDateTime); void PrintOrdersHistory(datetime fromDateTime, datetime toDateTime); void PrintPositionsHistory(datetime fromDateTime, datetime toDateTime); void PrintPendingOrdersHistory(datetime fromDateTime, datetime toDateTime); //-- bool GetDealsData(DealData &dealsData[], datetime fromDateTime, datetime toDateTime, string symbol, ulong magic); bool GetOrdersData(OrderData &ordersData[], datetime fromDateTime, datetime toDateTime, string symbol, ulong magic); bool GetPositionsData(PositionData &positionsData[], datetime fromDateTime, datetime toDateTime, string symbol, ulong magic); bool GetPendingOrdersData(PendingOrderData &pendingOrdersData[], datetime fromDateTime, datetime toDateTime, string symbol, ulong magic); //-- bool GetDealsData(DealData &dealsData[], datetime fromDateTime, datetime toDateTime); bool GetOrdersData(OrderData &ordersData[], datetime fromDateTime, datetime toDateTime); bool GetPositionsData(PositionData &positionsData[], datetime fromDateTime, datetime toDateTime); bool GetPendingOrdersData(PendingOrderData &pendingOrdersData[], datetime fromDateTime, datetime toDateTime); //-- bool GetAllDealsData(DealData &dealsData[]); bool GetAllOrdersData(OrderData &ordersData[]); bool GetAllPositionsData(PositionData &positionsData[]); bool GetAllPendingOrdersData(PendingOrderData &pendingOrdersData[]); //-- bool GetAllDealsData(DealData &dealsData[], string symbol, ulong magic); bool GetAllOrdersData(OrderData &ordersData[], string symbol, ulong magic); bool GetAllPositionsData(PositionData &positionsData[], string symbol, ulong magic); bool GetAllPendingOrdersData(PendingOrderData &pendingOrdersData[], string symbol, ulong magic); //-- bool GetLastClosedPositionData(PositionData &lastClosedPositionInfo); bool LastClosedPositionType(ENUM_POSITION_TYPE &lastClosedPositionType); bool LastClosedPositionVolume(double &lastClosedPositionVolume); bool LastClosedPositionSymbol(string &lastClosedPositionSymbol); bool LastClosedPositionTicket(ulong &lastClosedPositionTicket); bool LastClosedPositionProfit(double &lastClosedPositionProfit); bool LastClosedPositionNetProfit(double &lastClosedPositionNetProfit); bool LastClosedPositionPipProfit(int &lastClosedPositionPipProfit); bool LastClosedPositionClosePrice(double &lastClosedPositionClosePrice); bool LastClosedPositionOpenPrice(double &lastClosedPositionOpenPrice); bool LastClosedPositionSlPrice(double &lastClosedPositionSlPrice); bool LastClosedPositionTpPrice(double &lastClosedPositionTpPrice); bool LastClosedPositionSlPips(int &lastClosedPositionSlPips); bool LastClosedPositionTpPips(int &lastClosedPositionTpPips); bool LastClosedPositionOpenTime(datetime &lastClosedPositionOpenTime); bool LastClosedPositionCloseTime(datetime &lastClosedPositionCloseTime); bool LastClosedPositionSwap(double &lastClosedPositionSwap); bool LastClosedPositionCommission(double &lastClosedPositionCommission); bool LastClosedPositionInitiatedByPendingOrder(bool &lastClosedPositionInitiatedByPendingOrder); bool LastClosedPositionInitiatingOrderType(ENUM_ORDER_TYPE &lastClosedPositionInitiatingOrderType); bool LastClosedPositionId(ulong &lastClosedPositionId); bool LastClosedPositionOpeningOrderTicket(ulong &lastClosedPositionOpeningOrderTicket); bool LastClosedPositionOpeningDealTicket(ulong &lastClosedPositionOpeningDealTicket); bool LastClosedPositionClosingDealTicket(ulong &lastClosedPositionClosingDealTicket); bool LastClosedPositionMagic(ulong &lastClosedPositionMagic); bool LastClosedPositionComment(string &lastClosedPositionComment); bool LastClosedPositionDuration(long &lastClosedPositionDuration); //-- bool GetLastClosedProfitablePositionData(PositionData &lastClosedProfitablePositionInfo); bool GetLastClosedLossPositionData(PositionData &lastClosedLossPositionData); //-- bool GetLastFilledPendingOrderData(PendingOrderData &getLastFilledPendingOrderData); bool LastFilledPendingOrderType(ENUM_ORDER_TYPE &lastFilledPendingOrderType); bool LastFilledPendingOrderSymbol(string &lastFilledPendingOrderSymbol); bool LastFilledPendingOrderTicket(ulong &lastFilledPendingOrderTicket); bool LastFilledPendingOrderPriceOpen(double &lastFilledPendingOrderPriceOpen); bool LastFilledPendingOrderSlPrice(double &lastFilledPendingOrderSlPrice); bool LastFilledPendingOrderTpPrice(double &lastFilledPendingOrderTpPrice); bool LastFilledPendingOrderSlPips(int &lastFilledPendingOrderSlPips); bool LastFilledPendingOrderTpPips(int &lastFilledPendingOrderTpPips); bool LastFilledPendingOrderTimeSetup(datetime &lastFilledPendingOrderTimeSetup); bool LastFilledPendingOrderTimeDone(datetime &lastFilledPendingOrderTimeDone); bool LastFilledPendingOrderExpirationTime(datetime &lastFilledPendingOrderExpirationTime); bool LastFilledPendingOrderPositionId(ulong &lastFilledPendingOrderPositionId); bool LastFilledPendingOrderMagic(ulong &lastFilledPendingOrderMagic); bool LastFilledPendingOrderReason(ENUM_ORDER_REASON &lastFilledPendingOrderReason); bool LastFilledPendingOrderTypeFilling(ENUM_ORDER_TYPE_FILLING &lastFilledPendingOrderTypeFilling); bool LastFilledPendingOrderTypeTime(datetime &lastFilledPendingOrderTypeTime); bool LastFilledPendingOrderComment(string &lastFilledPendingOrderComment); //-- bool GetLastCanceledPendingOrderData(PendingOrderData &getLastCanceledPendingOrderData); bool LastCanceledPendingOrderType(ENUM_ORDER_TYPE &lastCanceledPendingOrderType); bool LastCanceledPendingOrderSymbol(string &lastCanceledPendingOrderSymbol); bool LastCanceledPendingOrderTicket(ulong &lastCanceledPendingOrderTicket); bool LastCanceledPendingOrderPriceOpen(double &lastCanceledPendingOrderPriceOpen); bool LastCanceledPendingOrderSlPrice(double &lastCanceledPendingOrderSlPrice); bool LastCanceledPendingOrderTpPrice(double &lastCanceledPendingOrderTpPrice); bool LastCanceledPendingOrderSlPips(int &lastCanceledPendingOrderSlPips); bool LastCanceledPendingOrderTpPips(int &lastCanceledPendingOrderTpPips); bool LastCanceledPendingOrderTimeSetup(datetime &lastCanceledPendingOrderTimeSetup); bool LastCanceledPendingOrderTimeDone(datetime &lastCanceledPendingOrderTimeDone); bool LastCanceledPendingOrderExpirationTime(datetime &lastCanceledPendingOrderExpirationTime); bool LastCanceledPendingOrderPositionId(ulong &lastCanceledPendingOrderPositionId); bool LastCanceledPendingOrderMagic(ulong &lastCanceledPendingOrderMagic); bool LastCanceledPendingOrderReason(ENUM_ORDER_REASON &lastCanceledPendingOrderReason); bool LastCanceledPendingOrderTypeFilling(ENUM_ORDER_TYPE_FILLING &lastCanceledPendingOrderTypeFilling); bool LastCanceledPendingOrderTypeTime(datetime &lastCanceledPendingOrderTypeTime); bool LastCanceledPendingOrderComment(string &lastCanceledPendingOrderComment); //* //-- bool GetLastClosedPositionData(PositionData &lastClosedPositionInfo, string symbol, ulong magic); bool LastClosedPositionType(ENUM_POSITION_TYPE &lastClosedPositionType, string symbol, ulong magic); bool LastClosedPositionVolume(double &lastClosedPositionVolume, string symbol, ulong magic); bool LastClosedPositionSymbol(string &lastClosedPositionSymbol, string symbol, ulong magic); bool LastClosedPositionTicket(ulong &lastClosedPositionTicket, string symbol, ulong magic); bool LastClosedPositionProfit(double &lastClosedPositionProfit, string symbol, ulong magic); bool LastClosedPositionNetProfit(double &lastClosedPositionNetProfit, string symbol, ulong magic); bool LastClosedPositionPipProfit(int &lastClosedPositionPipProfit, string symbol, ulong magic); bool LastClosedPositionClosePrice(double &lastClosedPositionClosePrice, string symbol, ulong magic); bool LastClosedPositionOpenPrice(double &lastClosedPositionOpenPrice, string symbol, ulong magic); bool LastClosedPositionSlPrice(double &lastClosedPositionSlPrice, string symbol, ulong magic); bool LastClosedPositionTpPrice(double &lastClosedPositionTpPrice, string symbol, ulong magic); bool LastClosedPositionSlPips(int &lastClosedPositionSlPips, string symbol, ulong magic); bool LastClosedPositionTpPips(int &lastClosedPositionTpPips, string symbol, ulong magic); bool LastClosedPositionOpenTime(datetime &lastClosedPositionOpenTime, string symbol, ulong magic); bool LastClosedPositionCloseTime(datetime &lastClosedPositionCloseTime, string symbol, ulong magic); bool LastClosedPositionSwap(double &lastClosedPositionSwap, string symbol, ulong magic); bool LastClosedPositionCommission(double &lastClosedPositionCommission, string symbol, ulong magic); bool LastClosedPositionInitiatingOrderType(ENUM_ORDER_TYPE &lastClosedPositionInitiatingOrderType, string symbol, ulong magic); bool LastClosedPositionId(ulong &lastClosedPositionId, string symbol, ulong magic); bool LastClosedPositionInitiatedByPendingOrder(bool &lastClosedPositionInitiatedByPendingOrder, string symbol, ulong magic); bool LastClosedPositionOpeningOrderTicket(ulong &lastClosedPositionOpeningOrderTicket, string symbol, ulong magic); bool LastClosedPositionOpeningDealTicket(ulong &lastClosedPositionOpeningDealTicket, string symbol, ulong magic); bool LastClosedPositionClosingDealTicket(ulong &lastClosedPositionClosingDealTicket, string symbol, ulong magic); bool LastClosedPositionMagic(ulong &lastClosedPositionMagic, string symbol, ulong magic); bool LastClosedPositionComment(string &lastClosedPositionComment, string symbol, ulong magic); bool LastClosedPositionDuration(long &lastClosedPositionDuration, string symbol, ulong magic); //-- bool GetLastClosedProfitablePositionData(PositionData &lastClosedProfitablePositionInfo, string symbol, ulong magic); bool GetLastClosedLossPositionData(PositionData &lastClosedLossPositionData, string symbol, ulong magic); //-- bool GetLastFilledPendingOrderData(PendingOrderData &lastFilledPendingOrderData, string symbol, ulong magic); bool LastFilledPendingOrderType(ENUM_ORDER_TYPE &lastFilledPendingOrderType, string symbol, ulong magic); bool LastFilledPendingOrderSymbol(string &lastFilledPendingOrderSymbol, string symbol, ulong magic); bool LastFilledPendingOrderTicket(ulong &lastFilledPendingOrderTicket, string symbol, ulong magic); bool LastFilledPendingOrderPriceOpen(double &lastFilledPendingOrderPriceOpen, string symbol, ulong magic); bool LastFilledPendingOrderSlPrice(double &lastFilledPendingOrderSlPrice, string symbol, ulong magic); bool LastFilledPendingOrderTpPrice(double &lastFilledPendingOrderTpPrice, string symbol, ulong magic); bool LastFilledPendingOrderSlPips(int &lastFilledPendingOrderSlPips, string symbol, ulong magic); bool LastFilledPendingOrderTpPips(int &lastFilledPendingOrderTpPips, string symbol, ulong magic); bool LastFilledPendingOrderTimeSetup(datetime &lastFilledPendingOrderTimeSetup, string symbol, ulong magic); bool LastFilledPendingOrderTimeDone(datetime &lastFilledPendingOrderTimeDone, string symbol, ulong magic); bool LastFilledPendingOrderExpirationTime(datetime &lastFilledPendingOrderExpirationTime, string symbol, ulong magic); bool LastFilledPendingOrderPositionId(ulong &lastFilledPendingOrderPositionId, string symbol, ulong magic); bool LastFilledPendingOrderMagic(ulong &lastFilledPendingOrderMagic, string symbol, ulong magic); bool LastFilledPendingOrderReason(ENUM_ORDER_REASON &lastFilledPendingOrderReason, string symbol, ulong magic); bool LastFilledPendingOrderTypeFilling(ENUM_ORDER_TYPE_FILLING &lastFilledPendingOrderTypeFilling, string symbol, ulong magic); bool LastFilledPendingOrderTypeTime(datetime &lastFilledPendingOrderTypeTime, string symbol, ulong magic); bool LastFilledPendingOrderComment(string &lastFilledPendingOrderComment, string symbol, ulong magic); //-- bool GetLastCanceledPendingOrderData(PendingOrderData &lastCanceledPendingOrderData, string symbol, ulong magic); bool LastCanceledPendingOrderType(ENUM_ORDER_TYPE &lastCanceledPendingOrderType, string symbol, ulong magic); bool LastCanceledPendingOrderSymbol(string &lastCanceledPendingOrderSymbol, string symbol, ulong magic); bool LastCanceledPendingOrderTicket(ulong &lastCanceledPendingOrderTicket, string symbol, ulong magic); bool LastCanceledPendingOrderPriceOpen(double &lastCanceledPendingOrderPriceOpen, string symbol, ulong magic); bool LastCanceledPendingOrderSlPrice(double &lastCanceledPendingOrderSlPrice, string symbol, ulong magic); bool LastCanceledPendingOrderTpPrice(double &lastCanceledPendingOrderTpPrice, string symbol, ulong magic); bool LastCanceledPendingOrderSlPips(int &lastCanceledPendingOrderSlPips, string symbol, ulong magic); bool LastCanceledPendingOrderTpPips(int &lastCanceledPendingOrderTpPips, string symbol, ulong magic); bool LastCanceledPendingOrderTimeSetup(datetime &lastCanceledPendingOrderTimeSetup, string symbol, ulong magic); bool LastCanceledPendingOrderTimeDone(datetime &lastCanceledPendingOrderTimeDone, string symbol, ulong magic); bool LastCanceledPendingOrderExpirationTime(datetime &lastCanceledPendingOrderExpirationTime, string symbol, ulong magic); bool LastCanceledPendingOrderPositionId(ulong &lastCanceledPendingOrderPositionId, string symbol, ulong magic); bool LastCanceledPendingOrderMagic(ulong &lastCanceledPendingOrderMagic, string symbol, ulong magic); bool LastCanceledPendingOrderReason(ENUM_ORDER_REASON &lastCanceledPendingOrderReason, string symbol, ulong magic); bool LastCanceledPendingOrderTypeFilling(ENUM_ORDER_TYPE_FILLING &lastCanceledPendingOrderTypeFilling, string symbol, ulong magic); bool LastCanceledPendingOrderTypeTime(datetime &lastCanceledPendingOrderTypeTime, string symbol, ulong magic); bool LastCanceledPendingOrderComment(string &lastCanceledPendingOrderComment, string symbol, ulong magic); //-- string BoolToString(bool boolVariable); datetime GetPeriodStart(int periodType); #import //+------------------------------------------------------------------+
Praktische Umsetzung und Überblick über die History Manager EX5 Bibliothek
Wir werden nun die Bibliotheksfunktionen untersuchen und sie zur besseren Übersichtlichkeit und Nutzerfreundlichkeit in ihre jeweiligen Kategorien einordnen. Dabei werden wir ihre Aufgaben beschreiben und anhand einfacher Anwendungsfälle demonstrieren, wie sie zur Bewältigung verschiedener Aufgaben eingesetzt werden können.
1. Drucken von Handelsverläufen für einen bestimmten Zeitbereich
Mit diesen Funktionen können Sie die Daten der Handelshistorie direkt in das Protokoll des MetaTrader 5-Terminals ausdrucken, was für eine schnelle Referenz und Fehlersuche praktisch ist. Sie sind vom Typ void, d. h. sie geben keine Werte zurück, und akzeptieren zwei Parameter vom Typ datetime , mit denen der Zeitbereich des zu verarbeitenden Verlaufs angegeben wird:
| Definition von Funktionsprototypen | Beschreibung | Beispiel für einen Anwendungsfall |
|---|---|---|
void PrintDealsHistory( datetime fromDateTime, datetime toDateTime ); | Druckt die Details zu allen Handelsgeschäften innerhalb eines bestimmten Zeitraums. | // Print the deals history for the last 24 hours (1 day)
PrintDealsHistory(ONE_DAY, NOW); |
void PrintOrdersHistory( datetime fromDateTime, datetime toDateTime ); | Druckt die Details zu allen Aufträge innerhalb eines bestimmten Zeitraums. | // Print the orders history for the last 24 hours (1 day)
PrintOrdersHistory(ONE_DAY, NOW); |
void PrintPositionsHistory( datetime fromDateTime, datetime toDateTime ); | Druckt die Details zu allen geschlossenen Positionen innerhalb eines bestimmten Zeitraums. | // Print the positions history for the last 24 hours (1 day)
PrintPositionsHistory(ONE_DAY, NOW); |
void PrintPendingOrdersHistory( datetime fromDateTime, datetime toDateTime ); | Druckt die Details zu allen schwebende Aufträgen innerhalb eines bestimmten Zeitraums. | // Print the pending orders history for the last 24 hours (1 day)
PrintPendingOrdersHistory(ONE_DAY, NOW); |
2. Abrufen von Handelsverlaufsdaten für einen bestimmten Zeitbereich
Mit diesen Funktionen können Sie programmgesteuert Daten zur Handelshistorie, gefiltert nach Symbol und magischer Zahl, für einen bestimmten Zeitraum abrufen. Die abgerufenen Daten werden in Datenstrukturarrays gespeichert, die eine weitere Analyse oder Verarbeitung ermöglichen:
| Definition von Funktionsprototypen | Beschreibung | Beispiel für einen Anwendungsfall |
|---|---|---|
bool GetDealsData( DealData &dealsData[], // [out] datetime fromDateTime, datetime toDateTime, string symbol, // Optional parameter ulong magic // Optional parameter ); | Mit dieser Funktion werden Handelsgeschäftsdaten innerhalb eines bestimmten Zeitraums gesucht und abgerufen. Außerdem bietet es die Möglichkeit, die abgerufenen Daten nach Symbolen und magischen Zahlen zu filtern, was eine gezieltere Verarbeitung ermöglicht. | // Print the total account net profit for the last 7 days DealData dealsData[]; if( GetDealsData( dealsData, ONE_WEEK, NOW, ALL_SYMBOLS, 0 ) && ArraySize(dealsData) > 0 ) { double totalGrossProfit = 0.0, totalSwap = 0.0, totalCommission = 0.0; int totalDeals = ArraySize(dealsData); for(int k = 0; k < totalDeals; k++) { if(dealsData[k].entry == DEAL_ENTRY_OUT) { totalGrossProfit += dealsData[k].profit; totalSwap += dealsData[k].swap; totalCommission += dealsData[k].commission; } } double totalExpenses = totalSwap + totalCommission; double totalNetProfit = totalGrossProfit - MathAbs(totalExpenses); Print("-------------------------------------------------"); Print( "Account No: ", AccountInfoInteger(ACCOUNT_LOGIN), " [ 7 DAYS NET PROFIT ]" ); Print( "Total Gross Profit: ", DoubleToString(totalGrossProfit, 2), " ", AccountInfoString(ACCOUNT_CURRENCY) ); Print( "Total Swap: ", DoubleToString(totalSwap, 2), " ", AccountInfoString(ACCOUNT_CURRENCY) ); Print( "Total Commission: ", DoubleToString(totalCommission, 2), " ", AccountInfoString(ACCOUNT_CURRENCY) ); Print( "Total Net Profit: ", DoubleToString(totalNetProfit, 2), " ", AccountInfoString(ACCOUNT_CURRENCY) ); } |
bool GetOrdersData( OrderData &ordersData[], // [out] datetime fromDateTime, datetime toDateTime, string symbol, // Optional parameter ulong magic // Optional parameter ); | Mit dieser Funktion werden Auftragsdaten innerhalb eines bestimmten Zeitraums abgefragt und abgerufen. Außerdem bietet es die Möglichkeit, die abgerufenen Daten nach Symbolen und magischen Zahlen zu filtern. | // Print the total BUY Orders filled in the last 7 days OrderData ordersData[]; if( GetOrdersData(ordersData, ONE_WEEK, NOW) && ArraySize(ordersData) > 0 ) { int totalBuyOrdersFilled = 0, totalOrders = ArraySize(ordersData); for(int w = 0; w < totalOrders; w++) { if(ordersData[w].type == ORDER_TYPE_BUY) ++totalBuyOrdersFilled; } Print(""); Print("-------------------------------------------------"); Print("Account No: ", AccountInfoInteger(ACCOUNT_LOGIN)); Print(totalBuyOrdersFilled, " BUY Orders Filled in the last 7 days!"); } |
bool GetPositionsData( PositionData &positionsData[], // [out] datetime fromDateTime, datetime toDateTime, string symbol, // Optional parameter ulong magic // Optional parameter ); | Mit dieser Funktion können Sie Daten über geschlossene Positionen innerhalb eines bestimmten Zeitraums suchen und abrufen. Sie haben die Möglichkeit, die abgerufenen Daten nach Symbolen und magischen Zahlenwerten zu filtern. | // Print total pips earned in last 24hrs for specified symbol and magic string symbol = _Symbol; long magic = 0; PositionData positionsData[]; if( GetPositionsData(positionsData, ONE_DAY, NOW, symbol, magic) && ArraySize(positionsData) > 0 ) { int totalPipsEarned = 0, totalPositions = ArraySize(positionsData); for(int k = 0; k < totalPositions; k++) { totalPipsEarned += positionsData[k].pipProfit; } Print(""); Print("-------------------------------------------------"); Print("Account No: ", AccountInfoInteger(ACCOUNT_LOGIN)); Print( totalPipsEarned, " pips earned in the last 24hrs for ", symbol, " with magic no. ", magic ); } |
bool GetPendingOrdersData( PendingOrderData &pendingOrdersData[], // [out] datetime fromDateTime, datetime toDateTime, string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion ruft die Datenhistorie der ausstehenden Aufträge innerhalb eines bestimmten Zeitraums ab. Sie haben auch die Möglichkeit, die Historie der ausstehenden Aufträge nach Symbol und magischer Zahl zu filtern. | // Print total number of buy and sell stops filled for symbol and magic // in the last 7 days string symbol = _Symbol; long magic = 0; PendingOrderData pendingOrdersData[]; if( GetPendingOrdersData(pendingOrdersData, ONE_WEEK, NOW, symbol, magic) && ArraySize(pendingOrdersData) > 0 ) { int totalBuyStopsFilled = 0, totalSellStopsFilled = 0, totalPendingOrders = ArraySize(pendingOrdersData); for(int k = 0; k < totalPendingOrders; k++) { if(pendingOrdersData[k].type == ORDER_TYPE_BUY_STOP) ++totalBuyStopsFilled; if(pendingOrdersData[k].type == ORDER_TYPE_SELL_STOP) ++totalSellStopsFilled; } Print(""); Print("-------------------------------------------------"); Print("Account No: ", AccountInfoInteger(ACCOUNT_LOGIN), ", Magic No = ", magic); Print( symbol, " --> Total Filled - (Buy Stops = ", totalBuyStopsFilled, ") (Sell Stops = ", totalSellStopsFilled, ") in the last 7 days." ); } |
3. Abrufen des gesamten historischen Handels
Diese Funktionen bieten eine umfassende Möglichkeit, alle verfügbaren Handelsdaten im Konto abzurufen, mit optionalen Filtern für Symbol und magische Zahl, ohne dass eine bestimmte Zeitspanne eingegeben werden muss:
| Definition von Funktionsprototypen | Beschreibung | Beispiel für einen Anwendungsfall |
|---|---|---|
bool GetAllDealsData( DealData &dealsData[], // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Die Funktion ruft alle Handelsgeschäftsdaten ab, wobei die Möglichkeit besteht, die Handelsgeschäftsverlaufsdaten nach Symbol und magischer Zahl zu filtern. | // Find and list total deposited funds in the account DealData dealsData[]; if(GetAllDealsData(dealsData) && ArraySize(dealsData) > 0) { double totalDeposits = 0.0; int totalDeals = ArraySize(dealsData); Print(""); for(int k = 0; k < totalDeals; k++) { if(dealsData[k].type == DEAL_TYPE_BALANCE) { totalDeposits += dealsData[k].profit; Print( dealsData[k].profit, " ", AccountInfoString(ACCOUNT_CURRENCY), " --> Cash deposit on: ", dealsData[k].time ); } } Print("-------------------------------------------------"); Print( "Account No: ", AccountInfoInteger(ACCOUNT_LOGIN), " Total Cash Deposits: ", totalDeposits, " ", AccountInfoString(ACCOUNT_CURRENCY) ); } |
bool GetAllOrdersData( OrderData &ordersData[], // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion ruft alle Auftragsdaten ab und bietet gleichzeitig die Möglichkeit, den Auftragsverlauf nach Symbol und magischer Zahl zu filtern. | // Find if the account has ever gotten a Stop Out/Margin Call OrderData ordersData[]; if(GetAllOrdersData(ordersData) && ArraySize(ordersData) > 0) { int totalStopOuts = 0; int totalOrders = ArraySize(ordersData); Print(""); for(int k = 0; k < totalOrders; k++) { if(ordersData[k].reason == ORDER_REASON_SO) { ++totalStopOuts; Print( EnumToString(ordersData[k].type), " --> on: ", ordersData[k].timeDone ); } } Print("-------------------------------------------------"); Print("Account No: ", AccountInfoInteger(ACCOUNT_LOGIN)); Print("Total STOP OUT events: ", totalStopOuts); } |
bool GetAllPositionsData( PositionData &positionsData[], // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Die Funktion ermittelt alle Positionsdaten mit der Möglichkeit, die Daten der geschlossenen Positionen nach Symbol und magischer Zahl zu filtern. | // Find the average trade duration in seconds PositionData positionsData[]; if(GetAllPositionsData(positionsData) && ArraySize(positionsData) > 0) { long totalTradesDuration = 0; int totalPositions = ArraySize(positionsData); Print(""); for(int k = 0; k < totalPositions; k++) { totalTradesDuration += positionsData[k].duration; } long averageTradesDuration = totalTradesDuration / totalPositions; Print("-------------------------------------------------"); Print("Account No: ", AccountInfoInteger(ACCOUNT_LOGIN)); Print("Average trade duration: ", averageTradesDuration, " seconds."); } |
bool GetAllPendingOrdersData( PendingOrderData &pendingOrdersData[], // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion ruft alle Daten zu ausstehenden Aufträgen ab, mit der Möglichkeit, die Historie der ausstehenden Aufträge nach Symbol und magischer Nummer zu filtern. | // Find the total expired pending orders in the account PendingOrderData pendingOrdersData[]; if(GetAllPendingOrdersData(pendingOrdersData) && ArraySize(pendingOrdersData) > 0) { int totalExpiredPendingOrders = 0; int totalPendingOrders = ArraySize(pendingOrdersData); Print(""); Print("-- EXPIRED PENDING ORDERS --"); for(int k = 0; k < totalPendingOrders; k++) { if(pendingOrdersData[k].state == ORDER_STATE_EXPIRED) { ++totalExpiredPendingOrders; Print("Symbol = ", pendingOrdersData[k].symbol); Print("Time Setup = ", pendingOrdersData[k].timeSetup); Print("Ticket = ", pendingOrdersData[k].ticket); Print("Price Open = ", pendingOrdersData[k].priceOpen); Print( "SL Price = ", pendingOrdersData[k].slPrice, ", TP Price = ", pendingOrdersData[k].tpPrice ); Print("Expiration Time = ", pendingOrdersData[k].expirationTime); Print(""); } } Print("-------------------------------------------------"); Print("Account No: ", AccountInfoInteger(ACCOUNT_LOGIN)); Print("Total Expired Pending Orders: ", totalExpiredPendingOrders); } |
4. Analyse der zuletzt geschlossenen Positionen
Diese Funktionen sind so konzipiert, dass sie umfassende Details über die zuletzt geschlossenen Positionen liefern und Einblicke in Schlüsselaspekte wie Gewinn oder Verlust, Handelsvolumen und den Zeitpunkt der Schließung jeder Position bieten. Jede Funktion dient einem bestimmten Zweck und stellt sicher, dass Sie Zugriff auf alle wichtigen Aspekte Ihres letzten Handelsgeschäfts haben. Die Funktionen bieten Ihnen auch die Möglichkeit, die zu verarbeitenden Positionsdaten nach Symbol und magischer Zahl zu filtern:
| Definition von Funktionsprototypen | Beschreibung | Beispiel für einen Anwendungsfall |
|---|---|---|
bool GetLastClosedPositionData( PositionData &lastClosedPositionInfo, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Die Funktion holt einen vollständigen Schnappschuss der endgültigen geschlossenen Position, einschließlich aller relevanten Details. Sie haben die Möglichkeit, das Ergebnis nach Symbol und magischer Zahl zu filtern. | // Get the last closed position in the account PositionData lastClosedPositionInfo; if( GetLastClosedPositionData(lastClosedPositionInfo) && lastClosedPositionInfo.ticket > 0 ) { // Process the last closed position data Print("---LAST CLOSED POSITION--"); Print("Symbol: ", lastClosedPositionInfo.symbol); Print("Type: ", EnumToString(lastClosedPositionInfo.type)); Print("Open Time: ", lastClosedPositionInfo.openTime); Print("Close Time: ", lastClosedPositionInfo.closeTime); Print("Profit: ", lastClosedPositionInfo.profit); // Place more position properties analysis code.... } //- // Get the last closed position for GBPUSD and magic 0 PositionData lastClosedPositionInfo; string symbol = "GBPUSD"; if( GetLastClosedPositionData(lastClosedPositionInfo, symbol, 0) && lastClosedPositionInfo.ticket > 0 ) { // Process the last closed position data Print("---LAST CLOSED POSITION FOR ", symbol, " --"); Print("Symbol: ", lastClosedPositionInfo.symbol); Print("Type: ", EnumToString(lastClosedPositionInfo.type)); Print("Open Time: ", lastClosedPositionInfo.openTime); Print("Close Time: ", lastClosedPositionInfo.closeTime); Print("Profit: ", lastClosedPositionInfo.profit); // Place more position properties analysis code.... } |
bool LastClosedPositionType( ENUM_POSITION_TYPE &lastClosedPositionType, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion zeigt an, ob die letzte Position ein Kauf- oder Verkaufsgeschäft war. Es besteht die Möglichkeit, die Daten nach Symbolen und magischen Zahlen zu filtern. | // Get the last closed position type in the account ENUM_POSITION_TYPE lastClosedPositionType; LastClosedPositionType(lastClosedPositionType); Print( "Account's last closed position type: ", EnumToString(lastClosedPositionType) ); //-- // Get the last closed position type for EURUSD and magic 0 ENUM_POSITION_TYPE lastClosedPositionType; LastClosedPositionType(lastClosedPositionType, "EURUSD", 0); Print( "EURUSD: last closed position type: ", EnumToString(lastClosedPositionType) ); |
bool LastClosedPositionVolume( double &lastClosedPositionVolume, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion liefert das Handelsvolumen der zuletzt geschlossenen Position. Die Funktion bietet Ihnen auch die Möglichkeit, die Daten nach Symbolen und magischen Zahlen zu filtern. | // Get the last closed position volume in the account double lastClosedPositionVolume; LastClosedPositionVolume(lastClosedPositionVolume); Print( "Account's last closed position volume: ", lastClosedPositionVolume ); //-- // Get the last closed position volume for GBPUSD and magic 0 double lastClosedPositionVolume; LastClosedPositionVolume(lastClosedPositionVolume, "GBPUSD", 0); Print( "GBPUSD: last closed position volume: ", lastClosedPositionVolume ); |
bool LastClosedPositionSymbol( string &lastClosedPositionSymbol, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Die Funktion ermittelt das Symbol der zuletzt geschlossenen Position. Gibt Ihnen die Möglichkeit, das Ergebnis nach Symbol und magischer Zahl zu filtern. | // Get the last closed position's symbol in the account string lastClosedPositionSymbol; LastClosedPositionSymbol(lastClosedPositionSymbol); Print( lastClosedPositionSymbol, " is the last closed position symbol ", "in the account" ); //-- // Get the last closed position's symbol for magic 0 string lastClosedPositionSymbol; LastClosedPositionSymbol(lastClosedPositionSymbol, ALL_SYMBOLS, 0); Print( lastClosedPositionSymbol, " is the last closed position symbol ", "for magic no: 0." ); |
bool LastClosedPositionTicket( ulong &lastClosedPositionTicket, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion ruft die Ticketnummer der zuletzt geschlossenen Position ab. Die Funktion hat die Möglichkeit, das Ergebnis nach Symbol und magischer Zahl zu filtern. | // Get the last closed position's ticket in the account long lastClosedPositionTicket; LastClosedPositionTicket(lastClosedPositionTicket); Print( "Account's last closed position's ticket: ", lastClosedPositionTicket ); //-- // Get the last closed position's ticket for EURUSD and magic 0 long lastClosedPositionTicket; LastClosedPositionTicket(lastClosedPositionTicket, "EURUSD", 0); Print( "EURUSD: last closed position's ticket: ", lastClosedPositionTicket ); |
bool LastClosedPositionProfit( double &lastClosedPositionProfit, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion liefert den Bruttogewinn, der durch das letzte Handelsgeschäft erzielt wurde. Sie haben auch die Möglichkeit, die Daten nach Symbolen und magischen Zahlen zu filtern. | // Get the last closed position's profit in the account double lastClosedPositionProfit; LastClosedPositionProfit(lastClosedPositionProfit); Print( "Account's last closed position's profit: ", lastClosedPositionProfit, " ", AccountInfoString(ACCOUNT_CURRENCY) ); //-- // Get the last closed position's profit for EURUSD and magic 0 //double lastClosedPositionProfit; LastClosedPositionProfit(lastClosedPositionProfit, "EURUSD", 0); Print( "EURUSD: last closed position's profit: ", lastClosedPositionProfit, " ", AccountInfoString(ACCOUNT_CURRENCY) ); |
Hier sind die übrigen Bibliotheksfunktionen, die für das Abrufen der Eigenschaften der letzten geschlossenen Position verantwortlich sind. Einzelheiten zur Implementierung finden Sie in den obigen Codebeispielen, einschließlich Funktionen wie LastClosedPositionVolume(), LastClosedPositionType() und andere, da sie alle einem ähnlichen Ansatz folgen.
| Definition von Funktionsprototypen | Beschreibung |
|---|---|
bool LastClosedPositionNetProfit( double &lastClosedPositionNetProfit, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Berechnet den Nettogewinn des letzten Handelsgeschäfts unter Berücksichtigung von Swaps und Provisionen. Die Funktion hat die Möglichkeit, die Daten nach Symbol und magischer Zahl zu filtern. |
bool LastClosedPositionPipProfit( int &lastClosedPositionPipProfit, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ermittelt den in Pips gemessenen Gewinn für die endgültig geschlossene Position. Die Daten können nach Symbol und magischer Zahl gefiltert werden. |
bool LastClosedPositionClosePrice( double &lastClosedPositionClosePrice, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft den Preis ab, zu dem die Position geschlossen wurde. Die Funktion bietet die Möglichkeit, das Ergebnis nach Symbol und magischer Zahl zu filtern. |
bool LastClosedPositionOpenPrice( double &lastClosedPositionOpenPrice, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Zeigt den Preis an, zu dem die Position ursprünglich eröffnet wurde. Optional können Sie die Daten nach Symbol und magischer Zahl filtern. |
bool LastClosedPositionSlPrice( double &lastClosedPositionSlPrice, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Holt den Stop-Loss-Kurs, der für die letzte geschlossene Position festgelegt wurde. Die Funktion bietet Ihnen die Möglichkeit, das Ergebnis nach Symbol und magischer Zahl zu filtern. |
bool LastClosedPositionTpPrice( double &lastClosedPositionTpPrice, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Liefert den Take-Profit-Kurs, der dem letzten abgeschlossenen Handelsgeschäft zugewiesen wurde. Eine Option zum Filtern der Daten nach Symbol und magischer Zahl ist ebenfalls vorhanden. |
bool LastClosedPositionSlPips( int &lastClosedPositionSlPips, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Zeigt den Stop-Loss-Abstand in Pips für die zuletzt geschlossene Position an. Die Datenfilterung nach Symbolen und magischen Zahlen wird ebenfalls unterstützt. |
bool LastClosedPositionTpPips( int &lastClosedPositionTpPips, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Zeigt den Take-Profit-Abstand in Pips für das zuletzt geschlossene Handelsgeschäft an. Die Funktion kann das Ergebnis auch optional nach Symbol und magischer Zahl filtern. |
bool LastClosedPositionOpenTime( datetime &lastClosedPositionOpenTime, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft den Zeitstempel ab, zu dem die letzte geschlossene Position geöffnet wurde. Die Daten lassen sich auch nach Symbolen und magischen Zahlen filtern. |
bool LastClosedPositionCloseTime( datetime &lastClosedPositionCloseTime, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Gibt den genauen Zeitpunkt an, zu dem die zuletzt geschlossene Position geschlossen wurde. Optional können Sie das Ergebnis auch nach Symbol und magischer Zahl filtern. |
bool LastClosedPositionSwap( double &lastClosedPositionSwap, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Zeigt den mit der letzten geschlossenen Position verbundenen Swap-Wert an. Die Informationen können optional auch nach Symbolen und magischen Zahlen gefiltert werden. |
bool LastClosedPositionCommission( double &lastClosedPositionCommission, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Holt die für das letzte abgeschlossene Handelsgeschäft berechnete Provision ab. Die Filterung nach Symbolen und magischen Zahlen wird ebenfalls unterstützt. |
bool LastClosedPositionInitiatingOrderType( ENUM_ORDER_TYPE &lastClosedPositionInitiatingOrderType, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Identifiziert die Art des Auftrags, der die letzte geschlossene Position ausgelöst hat. Sie können das Ergebnis optional nach Symbol und magischer Zahl filtern. |
bool LastClosedPositionId( ulong &lastClosedPositionId, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft die eindeutige Kennung für die zuletzt geschlossene Position ab. Die Parameter symbol und magic sind optional und nur erforderlich, wenn Sie das Ergebnis filtern müssen. |
bool LastClosedPositionInitiatedByPendingOrder( bool &lastClosedPositionInitiatedByPendingOrder, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Prüft, ob die letzte geschlossene Position durch einen schwebenden Auftrag ausgelöst oder eingeleitet wurde. Optional können Sie die Daten nach Symbol und magischer Zahl filtern. |
bool LastClosedPositionOpeningOrderTicket( ulong &lastClosedPositionOpeningOrderTicket, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Gibt die Ticketnummer des Auftrags an, der die Position eröffnet hat. Die Funktion kann die Daten auch optional nach Symbol und magischer Zahl filtern. |
bool LastClosedPositionOpeningDealTicket( ulong &lastClosedPositionOpeningDealTicket, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Holt die Ticketnummer des Handelsgeschäfts ab, das die Position ausgelöst hat. Sie haben die Möglichkeit, das Ergebnis nach Symbol und magischer Zahl zu filtern. |
bool LastClosedPositionClosingDealTicket( ulong &lastClosedPositionClosingDealTicket, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft die Ticketnummer des Handelsgeschäfts ab, mit dem die Position geschlossen wurde. Eine weitere Option ist das Filtern der Daten nach Symbolen und Magie. |
bool LastClosedPositionMagic( ulong &lastClosedPositionMagic, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Zeigt die magische Zahl an, die mit der letzten geschlossenen Position verbunden ist. Sie haben die Möglichkeit, die Daten nach Symbol und magischer Zahl zu filtern. |
bool LastClosedPositionComment( string &lastClosedPositionComment, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft alle Kommentare oder Notizen ab, die dem zuletzt abgeschlossenen Handelsgeschäft beigefügt sind. Die Filterung des Ergebnisses nach Symbolen und magischen Zahlen ist ebenfalls möglich. |
bool LastClosedPositionDuration( long &lastClosedPositionDuration, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Berechnet die Gesamtdauer (in Sekunden), die die Position offen war. Sie haben die Möglichkeit, das Ergebnis nach Symbol und magischer Zahl zu filtern. |
5. Analyse der zuletzt geschlossenen gewinnbringenden und verlustbringenden Positionen
Wenn Sie die Eigenschaften der letzten geschlossenen gewinnbringenden oder verlustbringenden Position abrufen müssen, bietet die History Manager-Bibliothek zwei spezielle Funktionen für diese Aufgabe. Mit diesen Funktionen können Sie mit einem einzigen Funktionsaufruf schnell auf alle relevanten Details zugreifen und so die zuletzt geschlossene Position auf ihre Rentabilität hin analysieren. Durch die Bereitstellung wichtiger Daten helfen sie bei der Bewertung der Handelsleistung und der Verfeinerung von Strategien. Darüber hinaus bieten diese Funktionen die Möglichkeit, die Ergebnisse nach einem bestimmten Symbol und einer magischen Zahl zu filtern, sodass Sie sich auf bestimmte Handelsgeschäfte konzentrieren und die Performance einzelner Strategien oder Vermögenswerte besser beurteilen können.
| Definition von Funktionsprototypen | Beschreibung | Beispiel für einen Anwendungsfall |
|---|---|---|
bool GetLastClosedProfitablePositionData( PositionData &lastClosedProfitablePositionInfo, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft die Details und Eigenschaften der zuletzt geschlossenen Position ab, die mit einem Gewinn abgeschlossen wurde. Die Funktion bietet Ihnen auch die Möglichkeit, die Ergebnisse nach Symbolen und magischen Zahlen zu filtern. | // Get the symbol, ticket, and net and pip profit of // the last closed profitable position PositionData lastClosedProfitablePosition; if( GetLastClosedProfitablePositionData(lastClosedProfitablePosition) && lastClosedProfitablePosition.ticket > 0 ) { Print("-------------------------------------------------"); Print( lastClosedProfitablePosition.symbol, " --> LAST CLOSED PROFITABLE POSITION" ); Print("Ticket = ", lastClosedProfitablePosition.ticket); Print( "Net Profit = ", lastClosedProfitablePosition.netProfit, " ", AccountInfoString(ACCOUNT_CURRENCY) ); Print("Pip Profit = ", lastClosedProfitablePosition.pipProfit); } //-- // Get the ticket, and net and pip profit of // the last closed profitable position for EURUSD and magic 0 PositionData lastClosedProfitablePosition; if( GetLastClosedProfitablePositionData( lastClosedProfitablePosition, "EURUSD", 0 ) && lastClosedProfitablePosition.ticket > 0 ) { Print("-------------------------------------------------"); Print("EURUSD --> LAST CLOSED PROFITABLE POSITION"); Print("Ticket = ", lastClosedProfitablePosition.ticket); Print( "Net Profit = ", lastClosedProfitablePosition.netProfit, " ", AccountInfoString(ACCOUNT_CURRENCY) ); Print("Pip Profit = ", lastClosedProfitablePosition.pipProfit); } |
bool GetLastClosedLossPositionData( PositionData &lastClosedLossPositionData, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft die Details und Eigenschaften der zuletzt geschlossenen Position ab, die geschlossen wurde oder zu einem Verlust geführt hat. Die Funktion ermöglicht es Ihnen auch, die Ergebnisse nach Symbolen und magischen Zahlen zu filtern. | // Get the symbol, ticket, and net and pip profit of // the last closed loss position PositionData lastClosedLossPosition; if( GetLastClosedLossPositionData(lastClosedLossPosition) && lastClosedLossPosition.ticket > 0 ) { Print("-------------------------------------------------"); Print( lastClosedLossPosition.symbol, " --> LAST CLOSED LOSS POSITION" ); Print("Ticket = ", lastClosedLossPosition.ticket); Print( "Net Profit = ", lastClosedLossPosition.netProfit, " ", AccountInfoString(ACCOUNT_CURRENCY) ); Print("Pip Profit = ", lastClosedLossPosition.pipProfit); } //-- // Get the ticket, and net and pip profit of // the last closed loss position for GBPUSD and magic 0 PositionData lastClosedLossPosition; if( GetLastClosedLossPositionData( lastClosedLossPosition, "GBPUSD", 0 ) && lastClosedLossPosition.ticket > 0 ) { Print("-------------------------------------------------"); Print("GBPUSD --> LAST CLOSED LOSS POSITION"); Print("Ticket = ", lastClosedLossPosition.ticket); Print( "Net Profit = ", lastClosedLossPosition.netProfit, " ", AccountInfoString(ACCOUNT_CURRENCY) ); Print("Pip Profit = ", lastClosedLossPosition.pipProfit); } |
6. Analyse der zuletzt ausgeführten und stornierten schwebenden Aufträge
Um detaillierte Informationen über den zuletzt ausgeführten oder stornierten schwebenden Auftrag abzurufen, bietet die History Manager-Bibliothek spezielle Funktionen für diesen Zweck. Diese Funktionen ermöglichen es Ihnen, alle relevanten Auftragsdetails mit einem einzigen Funktionsaufruf abzurufen, was die Analyse der Ausführung oder Stornierung von ausstehenden Aufträgen erleichtert. Durch die Bereitstellung von Schlüsseldaten helfen sie bei der Bewertung der Auftragsabwicklung, der Ausführungseffizienz und der Anpassung von Handelsstrategien. Darüber hinaus bieten diese Funktionen die Flexibilität, die Ergebnisse nach einem bestimmten Symbol und einer magischen Zahl zu filtern, sodass Sie sich auf bestimmte Aufträge konzentrieren und Ihre Vorgehensweise auf der Grundlage präziser historischer Daten verfeinern können.
Da die Funktionen für die zuletzt ausgeführten und stornierten schwebenden Aufträge nach demselben Ansatz importiert und implementiert werden wie die Funktionen, die die Historie der zuletzt geschlossenen Positionen verarbeiten, werden nur ihre Funktionsprototypen und Kurzbeschreibungen angegeben. Wenn Sie ein Beispiel für die Implementierung dieser Funktionen benötigen, lesen Sie den Abschnitt „Analyse der zuletzt geschlossenen Positionen“ weiter oben.
Die Funktion GetLastFilledPendingOrderData() ruft alle relevanten Eigenschaften des zuletzt ausgeführten Auftrags ab und bietet so einen umfassenden Überblick über die Ausführung des Auftrags. Wenn Sie nur bestimmte Attribute benötigen, können Sie mit den folgenden speziellen Funktionen einzelne Details oder Eigenschaften extrahieren:
| Definition von Funktionsprototypen | Beschreibung |
|---|---|
bool GetLastFilledPendingOrderData( PendingOrderData &lastFilledPendingOrderData, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion ruft alle relevanten Details des letzten ausstehenden Auftrags ab, der ausgeführt wurde, und gibt ein vollständiges Bild davon, wie der Auftrag ausgeführt wurde. |
bool LastFilledPendingOrderType( ENUM_ORDER_TYPE &lastFilledPendingOrderType, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft den Auftragstyp ab und hilft Ihnen festzustellen, ob es sich um einen Kaufstopp, ein Verkaufslimit oder eine andere Variante eines schwebenden Auftrags handelt. |
bool LastFilledPendingOrderSymbol( string &lastFilledPendingOrderSymbol, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Identifiziert das Handelsinstrument, sodass Sie sich auf Aufträge konzentrieren können, die mit einem bestimmten Vermögenswert verbunden sind. |
bool LastFilledPendingOrderTicket( ulong &lastFilledPendingOrderTicket, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Liefert das eindeutige Auftragsticket, das für die Referenzierung oder Verfolgung eines bestimmten ausgeführten Auftrags unerlässlich ist. |
bool LastFilledPendingOrderPriceOpen( double &lastFilledPendingOrderPriceOpen, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft den Preis ab, zu dem der Auftrag ausgelöst wurde, was für die Analyse der Einstiegsbedingungen von entscheidender Bedeutung ist. |
bool LastFilledPendingOrderSlPrice( double &lastFilledPendingOrderSlPrice, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); bool LastFilledPendingOrderTpPrice( double &lastFilledPendingOrderTpPrice, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktionen geben das Stop-Loss- bzw. Take-Profit-Niveau zurück, sodass Sie die Einstellungen für das Risikomanagement beurteilen können. |
bool LastFilledPendingOrderSlPips( int &lastFilledPendingOrderSlPips, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); bool LastFilledPendingOrderTpPips( int &lastFilledPendingOrderTpPips, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktionen drücken die Stop-Loss- und Take-Profit-Abstände in Pips aus und geben so einen besseren Überblick über das Risiko-Ertrags-Verhältnis des Handels. |
bool LastFilledPendingOrderTimeSetup( datetime &lastFilledPendingOrderTimeSetup, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); bool LastFilledPendingOrderTimeDone( datetime &lastFilledPendingOrderTimeDone, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | LastFilledPendingOrderTimeSetup() zeichnet auf, wann die Bestellung aufgegeben wurde, während LastFilledPendingOrderTimeDone() protokolliert, wann sie ausgeführt wurde. Dies hilft bei der Analyse der Zeitspanne zwischen der Einrichtung des schwebenden Auftrags und seiner Auslösung oder Ausführung. |
bool LastFilledPendingOrderExpirationTime( datetime &lastFilledPendingOrderExpirationTime, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Prüft und liefert die Verfallszeit, nützlich für zeitabhängige Handelsstrategien. |
bool LastFilledPendingOrderPositionId( ulong &lastFilledPendingOrderPositionId, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft die Positions-ID ab, die für die Verknüpfung des Auftrags mit der entsprechenden Position entscheidend ist und eine genaue Verfolgung gewährleistet. |
bool LastFilledPendingOrderMagic( ulong &lastFilledPendingOrderMagic, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft die magische Zahl ab, mit der Sie Aufträge auf der Grundlage von automatisierten Strategien oder Handelsroboter filtern können. |
bool LastFilledPendingOrderReason( ENUM_ORDER_REASON &lastFilledPendingOrderReason, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Erfasst den Grund für die Ausführung und bietet einen Einblick in die systembedingte oder manuelle Auftragsabwicklung. |
bool LastFilledPendingOrderTypeFilling( ENUM_ORDER_TYPE_FILLING &lastFilledPendingOrderTypeFilling, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); bool LastFilledPendingOrderTypeTime( datetime &lastFilledPendingOrderTypeTime, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | LastFilledPendingOrderTypeFilling() und LastFilledPendingOrderTypeTime() definieren die Methode der Auftragsbefüllung bzw. das Zeitmodell, was die Ausführungsanalyse erleichtert. |
bool LastFilledPendingOrderComment( string &lastFilledPendingOrderComment, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Holt alle zugehörigen Kommentare der zuletzt ausgeführten Pending Order ab, die für die Kennzeichnung und Kategorisierung von Handelsgeschäften nützlich sein können. |
Ähnlich verhält es sich mit der Funktion GetLastCanceledPendingOrderData(), die alle Details in einem Aufruf abruft, wenn Sie den letzten stornierten schwebenden Auftrag untersuchen wollen. Alternativ können Sie einzelne Eigenschaften mit den folgenden speziellen Funktionen extrahieren:
| Definition von Funktionsprototypen | Beschreibung |
|---|---|
bool GetLastCanceledPendingOrderData( PendingOrderData &lastCanceledPendingOrderData, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Diese Funktion liefert eine umfassende Aufzeichnung des zuletzt stornierten schwebenden Auftrags, einschließlich aller seiner Eigenschaften und Attribute. |
bool LastCanceledPendingOrderType( ENUM_ORDER_TYPE &lastCanceledPendingOrderType, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ruft den Typ des letzten stornierten schwebenden Auftrags ab und gibt ihn an. |
bool LastCanceledPendingOrderSymbol( string &lastCanceledPendingOrderSymbol, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ermittelt und identifiziert das Handelssymbol für den zuletzt stornierten schwebenden Auftrag und ermöglicht so eine gezielte Analyse. |
bool LastCanceledPendingOrderTicket( ulong &lastCanceledPendingOrderTicket, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Liefert die eindeutige Ticketnummer des letzten stornierten schwebenden Auftrags als Referenz |
bool LastCanceledPendingOrderPriceOpen( double &lastCanceledPendingOrderPriceOpen, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ermittelt und speichert den ursprünglich beabsichtigten Einstiegspreis des letzten stornierten schwebenden Auftrags. |
bool LastCanceledPendingOrderSlPrice( double &lastCanceledPendingOrderSlPrice, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); bool LastCanceledPendingOrderTpPrice( double &lastCanceledPendingOrderTpPrice, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | LastCanceledPendingOrderSlPrice() und LastCanceledPendingOrderTpPrice() rufen die Stop-Loss- und Take-Profit-Kurse der am häufigsten stornierten schwebenden Aufträge ab. |
bool LastCanceledPendingOrderSlPips( int &lastCanceledPendingOrderSlPips, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); bool LastCanceledPendingOrderTpPips( int &lastCanceledPendingOrderTpPips, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | LastCanceledPendingOrderSlPips() und LastCanceledPendingOrderTpPips() drücken die Stop-Loss- und Take-Profit-Abstände der letzten stornierten Pending Order in Pips aus. |
bool LastCanceledPendingOrderTimeSetup( datetime &lastCanceledPendingOrderTimeSetup, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); bool LastCanceledPendingOrderTimeDone( datetime &lastCanceledPendingOrderTimeDone, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | LastCanceledPendingOrderTimeSetup() liefert den Zeitpunkt, zu dem der letzte stornierte schwebende Auftrag erteilt wurde, während LastCanceledPendingOrderTimeDone() den Zeitpunkt erfasst, zu dem er durch Stornierung entfernt wurde. |
bool LastCanceledPendingOrderExpirationTime( datetime &lastCanceledPendingOrderExpirationTime, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ermittelt und speichert den Zeitpunkt, zu dem der stornierte schwebende Auftrag ablaufen sollte. |
bool LastCanceledPendingOrderMagic( ulong &lastCanceledPendingOrderMagic, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ermittelt und speichert die magische Zahl, die mit dem letzten stornierten schwebenden Auftrag verknüpft ist und ermöglicht die Filterung auf der Grundlage automatischer Strategiekennungen. |
bool LastCanceledPendingOrderReason( ENUM_ORDER_REASON &lastCanceledPendingOrderReason, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Ermittelt den Auftragsgrund des letzten stornierten schwebenden Auftrags und ermöglicht es uns festzustellen, auf welcher Plattform der Auftrag ausgelöst wurde. |
bool LastCanceledPendingOrderTypeFilling( ENUM_ORDER_TYPE_FILLING &lastCanceledPendingOrderTypeFilling, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); bool LastCanceledPendingOrderTypeTime( datetime &lastCanceledPendingOrderTypeTime, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | LastCanceledPendingOrderTypeFilling() und LastCanceledPendingOrderTypeTime() rufen die Einstellungen für die Füllung und den Zeittyp des zuletzt stornierten schwebenden Auftrags ab und speichern sie. |
bool LastCanceledPendingOrderComment( string &lastCanceledPendingOrderComment, // [Out] string symbol, // Optional parameter ulong magic // Optional parameter ); | Holt alle nutzerdefinierten Kommentare ab, die beim Öffnen des letzten stornierten schwebenden Auftrags zur Nachverfolgung gespeichert wurden. |
| Definition von Funktionsprototypen | Beschreibung |
|---|---|
string BoolToString(bool boolVariable); | Die Hilfsfunktion konvertiert einen booleschen Wert in eine Zeichenkette („TRUE“ oder „FALSE“), um die Lesbarkeit und Protokollierung zu erleichtern. |
datetime GetPeriodStart(int periodType); | Diese Hilfsfunktion gibt den Datumswert für den Beginn des Jahres, des Monats, der Woche (beginnend am Sonntag) oder des Tages zurück, je nach Eingabetyp. Es akzeptiert vordefinierte Makros aus der Header-Datei als Eingabe, nämlich HEUTE, DIESE_WOCHE, DIESER_MONAT und DIESES_JAHR. Diese Funktion vereinfacht den Prozess der Ermittlung des Datumswertes für diese Zeiträume und ermöglicht es Ihnen, dies mit einer einzigen Codezeile zu tun. |
Im nächsten Abschnitt werden wir anhand von praktischen Beispielen zeigen, wie die History Management-Bibliothek zur Erstellung aufschlussreicher Handelsanalysen genutzt werden kann. Darüber hinaus werden wir einen Expert Advisor entwickeln, der die Bibliothek der Historie nutzt, um das optimale Volumen oder Lot und die Positionsrichtung für die Ausführung neuer Handelsgeschäfte zu bestimmen. Dabei wird aufgezeigt, wie historische Daten effektiv in automatisierte Handelssysteme integriert werden können, um sowohl die Strategieausführung als auch die Entscheidungsfindung zu verbessern.
So berechnen Sie den Gewinnfaktor eines Expert Advisors oder Symbols, den Bruttogewinn/-verlust und den durchschnittlichen Bruttogewinn und -verlust pro Handelsgeschäft
Bei der Bewertung der Leistung eines Expert Advisors oder einer Handelsstrategie in MetaTrader 5 ist der Gewinnfaktor eine der wichtigsten Kennzahlen, die es zu berücksichtigen gilt. Der Gewinnfaktor bzw. Profit Factor ist eine Kennzahl, die den Bruttogewinn (gross profit) mit dem Bruttoverlust (gross loss) in einem bestimmten Zeitraum vergleicht. Sie gibt einen klaren Hinweis darauf, wie profitabel eine Handelsstrategie ist, indem sie die Gesamtgewinne mit den Gesamtverlusten vergleicht.
Ein hoher Gewinnfaktor zeigt an, dass die Strategie im Verhältnis zu ihren Verlusten mehr Gewinne erwirtschaftet, was eine wünschenswerte Eigenschaft für jedes Handelssystem ist. Umgekehrt deutet ein niedriger Gewinnfaktor darauf hin, dass die Strategie möglicherweise nicht so effektiv ist und weiter optimiert werden muss.
Der Gewinnfaktor wird nach der folgenden Formel berechnet:Profit Factor = Gross Profit / Gross Loss
wobei:
- Der Gross Profit (Bruttogewinn) ist der Gesamtbetrag, der mit allen profitablen Handelsgeschäften verdient wurde.
- Der Gross Loss (Bruttoverlust) ist der Gesamtbetrag des verlorenen Geldes aus allen Verlustgeschäften.
Ein Gewinnfaktor größer als 1 bedeutet, dass die Strategie profitabel ist, da der Bruttogewinn den Bruttoverlust übersteigt. Ein Gewinnfaktor von 1 bedeutet, dass der Bruttogewinn und der Bruttoverlust gleich sind, was auf ein Breakeven-Szenario hindeutet. Ein Gewinnfaktor von weniger als 1 bedeutet, dass die Strategie Geld verliert, da der Bruttoverlust den Bruttogewinn übersteigt.
Das Verständnis und die Berechnung des Gewinnfaktors sind für Händler und Entwickler von entscheidender Bedeutung, um fundierte Entscheidungen über die Durchführbarkeit und Leistung ihrer Handelsstrategien zu treffen.
In diesem Beispiel verwende ich die Bibliothek HistoryManager.ex5, um zu zeigen, wie einfach es ist, diese Berechnung in Ihrem MQL5-Code zu implementieren.
Erstellen wir zunächst einen neuen Expert Advisor und benennen ihn GetProfitFactor.mq5. Wir speichern ihn in folgendem Ordnerpfad: Experts\Wanateki\HistoryManager\GetProfitFactor.mq5. Beachten Sie, dass das Verzeichnis, in dem Sie den Expert Advisor speichern, wichtig ist, da es den Pfad beeinflusst, der zum Einbinden der Header-Datei verwendet wird, die die Prototyp-Definitionen der Bibliotheksfunktionen enthält.
Der Expert Advisor GetProfitFactor.mq5 hilft Ihnen bei der Analyse der Leistung Ihrer Handelsstrategien, indem er Schlüsselkennzahlen wie Bruttogewinn, Bruttoverlust und den Gewinnfaktor selbst berechnet.
Zunächst müssen wir die Bibliothek HistoryManager.ex5 einbinden und eine Enumeration definieren, die wir zur Eingabe des Symbolstringwerts in unserem Expert Advisor verwenden werden. Mit der Enumeration symbolName können wir angeben, ob wir das aktuelle Chartsymbol oder alle Symbole des Kontos analysieren wollen. Diese Enumeration in Verbindung mit der Eingabe der magischen Zahl ermöglicht es uns, die Ergebnisse so zu filtern, dass sie unseren Zielsymbolen und Expert Advisors entsprechen.
#include <Wanateki/Toolkit/HistoryManager/HistoryManager.mqh> //-- enum symbolName { CURRENT_CHART_SYMBOL, ALL_ACCOUNT_SYMBOLS, };
Als Nächstes definieren wir die Eingabeparameter, die der Nutzer des Expert Advisors zum Filtern der Ausgabe verwenden wird.
//--- input parameters input ulong magicNo = 0; //Magic Number (0 to disable) input symbolName getSymbolName = ALL_ACCOUNT_SYMBOLS;
Wir initialisieren die Variablen, die für die Speicherung unserer Berechnungen und die Anzeige der Ergebnisse verwendet werden sollen.
string currency = " " + AccountInfoString(ACCOUNT_CURRENCY); double totalGrossProfit = 0.0, totalGrossLoss = 0.0, averageGrossProfit = 0.0, averageGrossLoss = 0.0, averageProfitOrLossPerTrade = 0.0, profitFactor = 0.0; int totalTrades = 0, totalLossPositions = 0, totalProfitPositions = 0; string symbol, printedSymbol, profitFactorSummery, commentString;
In der Funktion OnInit() verwenden wir eine Switch-Anweisung, um das zu analysierende Symbol zu bestimmen. Sobald das Symbol identifiziert ist, rufen wir die Funktion CalcProfitFactor() auf, die für die Berechnung des Gewinnfaktors zuständig ist. Als erste Aufgabe, wenn der Expert Advisor geladen wird, werden wir dann alle Ergebnisse auf dem Chart mit der Funktion Comment() anzeigen.
int OnInit() { //--- switch(getSymbolName) { case CURRENT_CHART_SYMBOL: symbol = _Symbol; break; case ALL_ACCOUNT_SYMBOLS: symbol = ALL_SYMBOLS; break; default: symbol = ALL_SYMBOLS; } printedSymbol = symbol; if(symbol == "") printedSymbol = "ALL_SYMBOLS"; //-- CalcProfitFactor(); Comment(commentString); //--- return(INIT_SUCCEEDED); }
Bevor wir fortfahren, müssen wir die Funktion CalcProfitFactor() codieren, da sie den Großteil des Codes enthält, mit dem der GetProfitFactor Expert Advisor ausgeführt wird.
Wir beginnen die Funktion CalcProfitFactor() mit der Codierung der Funktionssignatur und setzen dann alle Variablen auf ihre Anfangswerte zurück. Dadurch wird sichergestellt, dass frühere Berechnungen die aktuelle Analyse nicht beeinträchtigen.
totalGrossProfit = 0.0; totalGrossLoss = 0.0; averageProfitOrLossPerTrade = 0.0; averageGrossProfit = 0.0; averageGrossLoss = 0.0; profitFactor = 0.0; totalTrades = 0; totalLossPositions = 0; totalProfitPositions = 0;
Als Nächstes verwenden wir die Funktion GetAllPositionsData(), um historische Handelsdaten abzurufen. Diese Funktion füllt das Array positionsData mit allen Handelspositionen, die auf dem angegebenen Symbol und der magischen Zahl basieren. Ebenso prüfen wir, ob die Funktion den Wert true zurückgibt und ob die Größe des Arrays größer als Null ist, um sicherzustellen, dass wir gültige Daten zur Verarbeitung haben. Dieser Schritt ist für den Zugriff auf die für unsere Berechnungen erforderlichen Handelsinformationen unerlässlich.
if(GetAllPositionsData(positionsData, symbol, magicNo) && ArraySize(positionsData) > 0) { //-- }
Anschließend werden die einzelnen Handelsgeschäfte im Array positionsData in einer Schleife durchlaufen, um den gesamten Bruttogewinn und -verlust zu berechnen. Bei jedem Handelsgeschäft wird geprüft, ob der Gewinn größer als Null ist, um festzustellen, ob es sich um ein profitables Handelsgeschäft handelt. Ist dies der Fall, wird der Zähler totalProfitPositions erhöht und der Gewinn zu totalGrossProfit addiert. Wenn der Gewinn kleiner oder gleich Null ist, wird der Zähler totalLossPositions erhöht und der absolute Wert des Gewinns zu totalGrossLoss addiert. Diese Schleife hilft uns, die Gesamtgewinne und -verluste aus allen Handelsgeschäften zu kumulieren.
totalTrades = ArraySize(positionsData); for(int r = 0; r < totalTrades; r++) { if(positionsData[r].profit > 0) // profitable trade { ++totalProfitPositions; totalGrossProfit += positionsData[r].profit; } else // loss trade { ++totalLossPositions; totalGrossLoss += MathAbs(positionsData[r].profit); } } // Calculate the profit factor and other data if(totalGrossProfit > 0 || totalGrossLoss > 0) averageProfitOrLossPerTrade = NormalizeDouble( (totalGrossProfit + totalGrossLoss) / totalTrades, 2 ); if(totalGrossProfit > 0) averageGrossProfit = NormalizeDouble( (totalGrossProfit / totalProfitPositions), 2 ); if(totalGrossLoss > 0) averageGrossLoss = NormalizeDouble( (totalGrossLoss / totalLossPositions), 2 ); //-- if(totalGrossLoss == 0.0) profitFactor = 0.0; // Avoid division by zero, indicating no losses profitFactor = totalGrossProfit / totalGrossLoss; }
Nachdem wir den Gesamtbruttogewinn und -verlust kumuliert haben, fahren wir mit der Berechnung verschiedener Kennziffern fort. Zunächst berechnen wir den durchschnittlichen Gewinn oder Verlust pro Handelsgeschäft, indem wir die Summe der gesamten Bruttogewinne und -verluste durch die Gesamtzahl der Handelsgeschäfte teilen. Außerdem berechnen wir den durchschnittlichen Bruttogewinn, indem wir den gesamten Bruttogewinn durch die Anzahl der profitablen Handelsgeschäfte teilen. In ähnlicher Weise berechnen wir den durchschnittlichen Bruttoverlust, indem wir den gesamten Bruttoverlust durch die Anzahl der Verlustgeschäfte teilen. Schließlich berechnen wir den Gewinnfaktor, indem wir den gesamten Bruttogewinn durch den gesamten Bruttoverlust dividieren. Diese Metriken bieten einen umfassenden Überblick über die Leistung der Handelsstrategie.
profitFactorSummery = "Profit Factor = " + DoubleToString(profitFactor, 2); if(profitFactor > 2.0) { profitFactorSummery = profitFactorSummery + "\nThe trading strategy is HIGHLY PROFITABLE and efficient."; } else if(profitFactor > 1.5) { profitFactorSummery = profitFactorSummery + "\nThe trading strategy is profitable and well-balanced."; } else if(profitFactor > 1.0) { profitFactorSummery = profitFactorSummery + "\nThe trading strategy is slightly profitable but may need improvement."; } else if(profitFactor == 1.0) { profitFactorSummery = profitFactorSummery + "\nThe strategy is break-even with no net gain or loss."; } else { profitFactorSummery = profitFactorSummery + "\nThe trading strategy is unprofitable and needs optimization."; }
Wir analysieren den Gewinnfaktor, um einen zusammenfassenden String zu erstellen, der die Leistung der Handelsstrategie beschreibt. Wir interpretieren den Gewinnfaktor folgendermaßen:
- Profit-Faktor > 2,0: Diese Strategie ist äußerst rentabel und effizient.
- Profit-Faktor zwischen 1,0 und 1,5: Die Strategie ist leicht profitabel, aber möglicherweise verbesserungswürdig.
- Gewinnfaktor = 1,0: Die Strategie ist kostendeckend, ohne Nettogewinn oder -verlust.
- Gewinnfaktor < 1,0: Die Strategie ist unrentabel und bedarf der Optimierung.
Diese Gewinnfaktoranalyse ermöglicht ein schnelles Verständnis der Gesamteffektivität der Handelsstrategie.
Schließlich erstellen wir einen detaillierten Kommentar, der alle berechneten Kennzahlen und die Zusammenfassung der Gewinnfaktoren enthält. Diese Zeichenkette ist so formatiert, dass sie das analysierte Symbol, die magische Zahl, die Gesamtzahl der Handelsgeschäfte, die Anzahl der gewinnbringenden und der verlustbringenden Handelsgeschäfte, den Gesamtbruttogewinn und -verlust, den durchschnittlichen Gewinn oder Verlust pro Handelsgeschäft, den durchschnittlichen Bruttogewinn und -verlust sowie die Gewinnfaktorzusammenfassung anzeigt.
Hier ist die vollständige Funktion CalcProfitFactor() mit allen Codesegmenten an ihrem Platz.
void CalcProfitFactor() { totalGrossProfit = 0.0; totalGrossLoss = 0.0; averageProfitOrLossPerTrade = 0.0; averageGrossProfit = 0.0; averageGrossLoss = 0.0; profitFactor = 0.0; totalTrades = 0; totalLossPositions = 0; totalProfitPositions = 0; //-- PositionData positionsData[]; if(GetAllPositionsData(positionsData, symbol, magicNo) && ArraySize(positionsData) > 0) { totalTrades = ArraySize(positionsData); for(int r = 0; r < totalTrades; r++) { if(positionsData[r].profit > 0) // profitable trade { ++totalProfitPositions; totalGrossProfit += positionsData[r].profit; } else // loss trade { ++totalLossPositions; totalGrossLoss += MathAbs(positionsData[r].profit); } } // Calculate the profit factor and other data if(totalGrossProfit > 0 || totalGrossLoss > 0) averageProfitOrLossPerTrade = NormalizeDouble( (totalGrossProfit + totalGrossLoss) / totalTrades, 2 ); if(totalGrossProfit > 0) averageGrossProfit = NormalizeDouble( (totalGrossProfit / totalProfitPositions), 2 ); if(totalGrossLoss > 0) averageGrossLoss = NormalizeDouble( (totalGrossLoss / totalLossPositions), 2 ); //-- if(totalGrossLoss == 0.0) profitFactor = 0.0; // Avoid division by zero, indicating no losses profitFactor = totalGrossProfit / totalGrossLoss; } // Analyze the Profit Factor result profitFactorSummery = "Profit Factor = " + DoubleToString(profitFactor, 2); if(profitFactor > 2.0) { profitFactorSummery = profitFactorSummery + "\nThe trading strategy is HIGHLY PROFITABLE and efficient."; } else if(profitFactor > 1.5) { profitFactorSummery = profitFactorSummery + "\nThe trading strategy is profitable and well-balanced."; } else if(profitFactor > 1.0) { profitFactorSummery = profitFactorSummery + "\nThe trading strategy is slightly profitable but may need improvement."; } else if(profitFactor == 1.0) { profitFactorSummery = profitFactorSummery + "\nThe strategy is break-even with no net gain or loss."; } else { profitFactorSummery = profitFactorSummery + "\nThe trading strategy is unprofitable and needs optimization."; } commentString = "\n\n-----------------------------------------------------------------------------------------------------" + "\n HistoryManager.ex5 --- PROFIT FACTOR ANALYTICS ---" + "\n-----------------------------------------------------------------------------------------------------" + "\n -> Symbol = " + printedSymbol + "\n -> Magic No = " + IntegerToString(magicNo) + "\n-----------------------------------------------------------------------------------------------------" + "\n-----------------------------------------------------------------------------------------------------" + "\n" + profitFactorSummery + "\n-----------------------------------------------------------------------------------------------------" + "\n-----------------------------------------------------------------------------------------------------" + "\n -> Total Trades Analysed = " + IntegerToString(totalTrades) + "\n -> Total Profitable Trades = " + IntegerToString(totalProfitPositions) + "\n -> Total Loss Trades = " + IntegerToString(totalLossPositions) + "\n --------------------------------------------------------" + "\n -> Total Gross Profit = " + DoubleToString(totalGrossProfit, 2) + currency + "\n -> Total Gross Loss = -" + DoubleToString(totalGrossLoss, 2) + currency + "\n ----------------------------------" + "\n -> Total Gross (Profit - Loss) = " + DoubleToString(totalGrossProfit - totalGrossLoss, 2) + currency + "\n --------------------------------------------------------" + "\n -> Average Profit or Loss Per Trade = (-/+)" + DoubleToString(averageProfitOrLossPerTrade, 2) + currency + "\n --------------------------------------------------------" + "\n -> Average Gross Profit = " + DoubleToString(averageGrossProfit, 2) + currency + "\n -> Average Gross Loss = -" + DoubleToString(averageGrossLoss, 2) + currency + "\n --------------------------------------------------------" + "\n-----------------------------------------------------------------------------------------------------"; //-- }
Wir platzieren die Funktion auch innerhalb der Standardfunktion OnTrade(), um sie auszuführen und den Profit Factor nach jeder Handelsoperation neu zu berechnen.
void OnTrade() { //--- CalcProfitFactor(); }
Um sicherzustellen, dass die Daten im Chart aktualisiert werden, verwenden wir die Funktion Comment(), um den commentString zu drucken, der alle Informationen über den aktuell aktualisierten Profit-Faktor enthält, und drucken ihn nach jedem neuen Tick mit der Standardfunktion OnTick().
void OnTick() { //--- Comment(commentString); }
Hier sehen Sie die Ausgabe des GetProfitFactor Expert Advisor im MetaTrader 5 Chartfenster.
Die Quelldatei GetProfitFactor.mq5 ist am Ende dieses Artikels zu Ihrer Information angehängt.
So berechnen Sie den monetären Brutto- und Nettogewinn der aktuellen Woche für einen bestimmten Expert Advisor oder ein Symbol
In diesem Beispiel werden wir ein MQL5-Skript erstellen, das einen umfassenden Überblick über die finanzielle Leistung für die aktuelle Woche gibt, einschließlich Bruttogewinn, Swaps, Provisionen und Nettogewinn. Hier wird gezeigt, wie Sie die Bibliothek History Manager nutzen können, um die wöchentliche Performance des gesamten Kontos, eines bestimmten Symbols oder der magischen Zahl eines Expert Advisors direkt im MetaTrader 5-Terminal zu bewerten.
Wir beginnen mit der Erstellung eines neuen Skripts namens GetNetProfitThisWeek.mq5 und speichern es in diesem Ordner: Scripts\Wanateki\HistoryManager\GetNetProfitThisWeek.mq5. Wir fügen in die neue Skriptdatei zunächst die Bibliothek HistoryManager.mqh ein, die uns den Zugriff auf alle Bibliotheksfunktionen ermöglicht.
#include <Wanateki/Toolkit/HistoryManager/HistoryManager.mqh> Als Nächstes werden wir unseren gesamten Code in der Funktion OnStart() unterbringen, um die Dinge einfach und klar zu halten. Der erste Teil des Skripts besteht darin, eine String-Variable zu initialisieren, in der die Kontowährung gespeichert wird. Dies wird zur Formatierung der Ausgabe von Finanzkennzahlen verwendet.
string currency = " " + AccountInfoString(ACCOUNT_CURRENCY);
Bevor wir mit den Berechnungen beginnen können, müssen wir zunächst die Anfangszeit der aktuellen Woche berechnen. Dies ist sehr einfach, da die Bibliothek HistoryManager.ex5 die Funktion GetPeriodStart() enthält, mit der wir den Datumswert für den Beginn der aktuellen Woche abrufen können. Um diesen Wert zu erhalten, müssen wir nur die FunktionGetPeriodStart() mit dem Parameter THIS_WEEK als Eingabe aufrufen. Auf diese Weise können wir Handelsgeschäfte herausfiltern, die in der aktuellen Woche stattgefunden haben.
datetime thisWeekStartTime = GetPeriodStart(THIS_WEEK); Wir deklarieren ein Array, um die Handelsgeschäftsdaten zu speichern, und verwenden die Funktion GetDealsData(), um es mit den Handelsgeschäften zu füllen, die zwischen dem Beginn der aktuellen Woche und dem aktuellen Zeitpunkt (NOW) stattgefunden haben. Ebenso filtern wir Handelsgeschäfte für alle Symbole mit einer magischen Zahl von 0.
if( GetDealsData( dealsData, thisWeekStartTime, NOW, ALL_SYMBOLS, 0 ) && ArraySize(dealsData) > 0 )
Wir initialisieren Variablen, um den gesamten Bruttogewinn, den gesamten Swap und die gesamte Provision zu speichern. Diese Variablen werden verwendet, um die entsprechenden Werte aus den Handelsgeschäftsdaten zu akkumulieren.
double totalGrossProfit = 0.0, totalSwap = 0.0, totalCommission = 0.0;
Wir gehen in einer Schleife durch jeden Deal im Array dealsData. Für jeden Deal wird geprüft, ob es sich um ein Abschlussgeschäft handelt (DEAL_ENTRY_OUT). Wenn dies der Fall ist, addieren wir den Gewinn, den Swap und die Provision zu ihren jeweiligen Gesamtvariablen.
int totalDeals = ArraySize(dealsData); for(int k = 0; k < totalDeals; k++) { if(dealsData[k].entry == DEAL_ENTRY_OUT) { totalGrossProfit += dealsData[k].profit; totalSwap += dealsData[k].swap; totalCommission += dealsData[k].commission; } }
Wir berechnen die Gesamtkosten, indem wir die Gesamtsumme der Swaps und Provisionen addieren. Außerdem berechnen wir den gesamten Nettogewinn, indem wir die Gesamtkosten vom gesamten Bruttogewinn abziehen.
double totalExpenses = totalSwap + totalCommission; double totalNetProfit = totalGrossProfit - MathAbs(totalExpenses);
Wir verwenden die Funktion Print(), um die Ergebnisse in das MetaTrader 5-Protokoll auszugeben. Dazu gehören der gesamte Bruttogewinn, die gesamten Swaps, die gesamte Provision und der gesamte Nettogewinn für die laufende Woche. Außerdem verwenden wir die Funktion Comment(), um die Ergebnisse direkt im Chartfenster anzuzeigen. Dazu gehört eine detaillierte Zusammenfassung der Finanzkennzahlen für die laufende Woche.
Hier ist die vollständige Funktion OnStart() mit allen Codesegmenten in der richtigen Reihenfolge und in voller Länge.
void OnStart() { //--- string currency = " " + AccountInfoString(ACCOUNT_CURRENCY); datetime thisWeekStartTime = GetPeriodStart(THIS_WEEK); DealData dealsData[]; if( GetDealsData( dealsData, thisWeekStartTime, NOW, ALL_SYMBOLS, 0 ) && ArraySize(dealsData) > 0 ) { double totalGrossProfit = 0.0, totalSwap = 0.0, totalCommission = 0.0; int totalDeals = ArraySize(dealsData); for(int k = 0; k < totalDeals; k++) { if(dealsData[k].entry == DEAL_ENTRY_OUT) { totalGrossProfit += dealsData[k].profit; totalSwap += dealsData[k].swap; totalCommission += dealsData[k].commission; } } double totalExpenses = totalSwap + totalCommission; double totalNetProfit = totalGrossProfit - MathAbs(totalExpenses); Print("-------------------------------------------------"); Print( "Account No: ", AccountInfoInteger(ACCOUNT_LOGIN), " [ THIS WEEK'S NET PROFIT ]" ); Print( "Total Gross Profit This Week: ", DoubleToString(totalGrossProfit, 2), " ", currency ); Print( "Total Swaps This Week: ", DoubleToString(totalSwap, 2), " ", currency ); Print( "Total Commission This Week: ", DoubleToString(totalCommission, 2), " ", currency ); Print( "Total Net Profit This Week: ", DoubleToString(totalNetProfit, 2), " ", currency ); //-- Comment( "\n\n-----------------------------------------------------------------------------------------------------" + "-------------------------------------------------------------------" + "\n HistoryManager.ex5 --- TOTAL NET PROFIT THIS WEEK ---" + "\n-----------------------------------------------------------------------------------------------------" + "------------------------------------------------------" + "\n DATE = ( From: " + TimeToString(thisWeekStartTime) + ", to: " + TimeToString(NOW) + " )" + "\n Account No = " + IntegerToString(AccountInfoInteger(ACCOUNT_LOGIN)) + "\n------------------------------------------------------" + "\n -> Total Gross Profit = " + DoubleToString(totalGrossProfit, 2) + currency + "\n -> Total Swaps = " + DoubleToString(totalSwap, 2) + currency + "\n -> Total Commission = " + DoubleToString(totalCommission, 2) + currency + "\n-----------------------------------------------------------------------------------------------------" + "------------------------------------------------------" + "\n -> TOTAL NET PROFIT = " + DoubleToString(totalNetProfit, 2) + currency + "\n-----------------------------------------------------------------------------------------------------" + "------------------------------------------------------" + "\n-----------------------------------------------------------------------------------------------------" + "-------------------------------------------------------------------" ); } }
Für den vollständigen Quellcode des Skripts laden Sie bitte die Datei GetNetProfitThisWeek.mq5 herunter, die Sie am Ende dieses Artikels finden.
So berechnen wir das Gewinn-Verlust-Verhältnis in Pips für ein bestimmtes Symbol oder einen Expert Advisor
In diesem Beispiel werden wir untersuchen, wie man das Gewinn-Verlust-Verhältnis in Pips für ein bestimmtes Handelssymbol oder einen ganzen Expert Advisor mit MQL5 berechnet. Diese Berechnung ist ein wichtiges Instrument für die Bewertung der Leistung einer Handelsstrategie, da sie eine klare und quantifizierbare Metrik liefert, um festzustellen, ob die Strategie profitabel, kostendeckend oder unprofitabel ist, basierend auf den gewonnenen oder verlorenen Pips. Der mitgelieferte Code wurde entwickelt, um historische Handelsdaten zu analysieren, das Verhältnis zu berechnen und die Ergebnisse in einem nutzerfreundlichen und leicht zu interpretierenden Format zu präsentieren.
Wir nennen den Expert Advisor GetSymbolPipsProfitToLossRatio.mq5, speichern ihn im entsprechenden Ordner und fangen an, indem wir die Bibliothek HistoryManager.mqh als erste und wichtigste Zeile in unsere Quelldatei aufnehmen. Als Nächstes erstellen wir ein Enum, um den Symbolnamen zu speichern und die Eingabeparameter (Symbol und magische Zahl) zu definieren. Diese Parameter ermöglichen es dem Nutzer, die Datenergebnisse nach seinen Präferenzen zu filtern: ob er alle geschlossenen Positionen für ein bestimmtes Symbol, geschlossene Positionen für ein bestimmtes Symbol, das eine bestimmte magische Zahl enthält, oder alle Positionen mit einer bestimmten magischen Zahl, unabhängig vom Symbol, analysieren möchte.
In der Funktion OnInit() wird die Kontowährung abgerufen und das/die zu analysierende(n) Symbol(e) auf der Grundlage der Nutzereingaben bestimmt. Wenn der Nutzer CURRENT_CHART_SYMBOL auswählt, wird sich unser Expert Advisor auf das Symbol des aktuellen Charts konzentrieren. Wenn sie ALL_ACCOUNT_SYMBOLS auswählen, werden alle auf dem Konto gehandelten Symbole analysiert.
Wir werden die Funktion GetAllPositionsData() verwenden, um historische Handelsdaten für das/die angegebene(n) Symbol(e) und die magische Zahl abzurufen. Diese Daten werden in einem Array der Strukturen PositionData gespeichert. Ebenso werden wir dann durch das Array iterieren, um die Handelsgeschäfte entweder als gewinnbringend oder als verlustbringend zu kategorisieren. Während dieses Prozesses berechnen wir die Summe der Pips, die wir durch gewinnbringende Handelsgeschäfte gewonnen haben (totalPipsProfit) und die Summe der Pips, die wir durch Handelsgeschäfte mit Verlust verloren haben (totalPipsLoss).
Um das Gewinn/Verlust-Verhältnis in Pips zu berechnen, teilen wir die insgesamt gewonnenen Pips durch die insgesamt verlorenen Pips. Außerdem werden wir den absoluten Wert verwenden, um sicherzustellen, dass das Verhältnis immer positiv ist. Wenn es keine Verlustgeschäfte gibt (totalPipsLoss == 0), ist das Verhältnis undefiniert, und der Expert Advisor gibt eine Meldung aus, dass die Strategie keine Verlustgeschäfte hat. Der Expert Advisor wird das Verhältnis wie folgt interpretieren:
- Verhältnis > 1,0: Die Strategie ist profitabel, da sie mehr Pips gewinnt als sie verliert.
- Verhältnis == 1,0: Die Strategie ist in Bezug auf die Anzahl der Pips ausgeglichen.
- Verhältnis < 1,0: Die Strategie ist unrentabel, da sie mehr Pips verliert als sie gewinnt.
Wir werden die Funktion Comment() verwenden, um die Analyseergebnisse direkt im Chart anzuzeigen. Die Ausgabe wird Folgendes enthalten: Das/die analysierte(n) Symbol(e), die verwendete magische Zahl (falls vorhanden), die Gesamtzahl der analysierten Handelsgeschäfte, die Anzahl der gewinnbringenden und verlustbringenden Handelsgeschäfte sowie die insgesamt gewonnenen und verlorenen Pips und das berechnete Gewinn/Verlust-Verhältnis in Pips und dessen Interpretation.
In der Funktion OnDeinit() führen wir eine einfache Bereinigung durch, indem wir die Chart-Kommentare löschen, wenn der Expert Advisor entfernt oder deinitialisiert wird, um einen sauberen Arbeitsbereich zu gewährleisten. Wir lassen die Funktion OnTick() leer, da die Analyse nur einmal während der Initialisierung durchgeführt wird. Sie können diese Funktion jedoch erweitern, um bei Bedarf Berechnungen oder Aktualisierungen in Echtzeit durchzuführen.
Hier sind alle Codesegmente in ihrer korrekten Reihenfolge aufgeführt:
//-- #include <Wanateki/Toolkit/HistoryManager/HistoryManager.mqh> //-- enum symbolName { CURRENT_CHART_SYMBOL, ALL_ACCOUNT_SYMBOLS, }; //--- input parameters input ulong magicNo = 0; //Magic Number (0 to disable) input symbolName getSymbolName = CURRENT_CHART_SYMBOL;
int OnInit() { //--- string currency = " " + AccountInfoString(ACCOUNT_CURRENCY); string symbol, printedSymbol; switch(getSymbolName) { case CURRENT_CHART_SYMBOL: symbol = _Symbol; break; case ALL_ACCOUNT_SYMBOLS: symbol = ALL_SYMBOLS; break; default: symbol = ALL_SYMBOLS; } printedSymbol = symbol; if(symbol == "") printedSymbol = "ALL_SYMBOLS"; //-- int totalTrades = 0; int totalLossPositions = 0; int totalProfitPositions = 0; double totalPipsProfit = 0; double totalPipsLoss = 0; string interpretation; double pipsProfitToLossRatio = 0; //-- PositionData positionsData[]; if(GetAllPositionsData(positionsData, symbol, magicNo) && ArraySize(positionsData) > 0) { totalTrades = ArraySize(positionsData); for(int r = 0; r < totalTrades; r++) { if(positionsData[r].profit > 0) // profitable trade { ++totalProfitPositions; totalPipsProfit += positionsData[r].pipProfit; } else // loss trade { ++totalLossPositions; totalPipsLoss += positionsData[r].pipProfit; } } // Calculate the pip profit loss ratioInterpretation if(totalPipsLoss == 0) { interpretation = "Pips Profit-to-Loss Ratio: Undefined (Total pips loss is zero)." + "The strategy has no losing trades."; } else { pipsProfitToLossRatio = fabs(totalPipsProfit / totalPipsLoss); switch(pipsProfitToLossRatio > 1.0 ? 1 : pipsProfitToLossRatio == 1.0 ? 0 : -1) { case 1: interpretation = "Pips Profit-to-Loss Ratio: " + DoubleToString(pipsProfitToLossRatio, 2) + ". The strategy is profitable as it gains more pips than it loses."; break; case 0: interpretation = "Pips Profit-to-Loss Ratio: " + DoubleToString(pipsProfitToLossRatio, 2) + ". The strategy breaks even in terms of pips."; break; case -1: interpretation = "Pips Profit-to-Loss Ratio: " + DoubleToString(pipsProfitToLossRatio, 2) + ". The strategy is unprofitable as it loses more pips than it gains."; break; } } Comment( "\n\n-----------------------------------------------------------------------------------------------------" + "---------------------------" + "\n HistoryManager.ex5 --- PIPS PROFIT TO LOSS RATIO ---" + "\n-----------------------------------------------------------------------------------------------------" + "---------------------------" + "\n -> Symbol = " + printedSymbol + "\n -> Magic No = " + IntegerToString(magicNo) + "\n-----------------------------------------------------------------------------------------------------" + "---------------------------" + "\n-----------------------------------------------------------------------------------------------------" + "---------------------------" + "\n" + interpretation + "\n-----------------------------------------------------------------------------------------------------" + "---------------------------" + "\n-----------------------------------------------------------------------------------------------------" + "---------------------------" + "\n -> Total Trades Analysed = " + IntegerToString(totalTrades) + "\n -> Total Profitable Trades = " + IntegerToString(totalProfitPositions) + " ( " + DoubleToString(totalPipsProfit, 0) + " Pips )" + "\n -> Total Loss Trades = " + IntegerToString(totalLossPositions) + " ( " + DoubleToString(totalPipsLoss, 0) + " Pips )" + "\n --------------------------------------------------------------------------" + "\n -> PIPS PROFIT TO LOSS RATIO = " + DoubleToString(pipsProfitToLossRatio, 2) + "\n --------------------------------------------------------------------------" + "\n-----------------------------------------------------------------------------------------------------" + "---------------------------" ); } //--- return(INIT_SUCCEEDED); }
Sie können die vollständige Datei GetSymbolPipsProfitToLossRatio.mq5 am Ende dieses Artikels herunterladen.
So ermitteln Sie den Gesamtbarwert von Kontoeinlagen
In diesem Abschnitt erstellen wir ein einfaches MQL5-Skript namens GetTotalDeposits.mq5, das die Funktion GetAllDealsData() aus unserer Bibliothek nutzt, um Handelsgeschäftsdaten abzurufen und zu analysieren, damit Sie einen klaren Überblick über den Finanzierungsverlauf Ihres Kontos erhalten. Dies ist ein wertvolles Tool, das Sie in Ihrem Werkzeugkasten haben, wenn Sie algorithmisch die Gesamtsumme der auf Ihr Handelskonto eingezahlten Gelder nachverfolgen, den Finanzierungsverlauf Ihres Kontos für Aufzeichnungs- oder Steuerzwecke prüfen oder einfach Einzahlungstransaktionen auf ihre Richtigkeit hin überprüfen möchten.
Wir werden die Funktion GetAllDealsData() verwenden, um alle historischen Handelsgeschäftsdaten für das Konto abzurufen. Diese Daten werden in einem Array von DealData-Strukturen gespeichert. Als Nächstes initialisieren wir eine Variable, um den Gesamtwert der Einlage zu speichern und die Handelsgeschäftsdaten zu durchlaufen. Wir identifizieren Einzahlungstransaktionen, indem wir prüfen, ob der Deal-Typ DEAL_TYPE_BALANCE ist. Wir addieren die Gewinnwerte dieser Handelsgeschäfte, um die Gesamteinlagen zu berechnen.
Nachdem wir alle Zieldaten berechnet und gespeichert haben, drucken wir den Gesamtwert der Einlage auf dem Terminal aus und zeigen ihn mit der Funktion Comment() im Chart an. Dies bietet eine nutzerfreundliche Übersicht über die Einzahlungshistorie des Kontos.
#include <Wanateki/Toolkit/HistoryManager/HistoryManager.mqh> void OnStart() { //--- // Find and list total deposited funds in the account DealData dealsData[]; if(GetAllDealsData(dealsData) && ArraySize(dealsData) > 0) { double totalDeposits = 0.0; int totalDeals = ArraySize(dealsData); Print(""); for(int k = 0; k < totalDeals; k++) { if(dealsData[k].type == DEAL_TYPE_BALANCE) { totalDeposits += dealsData[k].profit; Print( dealsData[k].profit, " ", AccountInfoString(ACCOUNT_CURRENCY), " --> Cash deposit on: ", dealsData[k].time ); } } Print("-------------------------------------------------"); Print( "Account No: ", AccountInfoInteger(ACCOUNT_LOGIN), " Total Cash Deposits: ", totalDeposits, " ", AccountInfoString(ACCOUNT_CURRENCY) ); Comment( "\n\n-----------------------------------------------------------------------------------------------------" + "---------------------------------------------------------" + "\n HistoryManager.ex5 --- TOTAL ACCOUNT DEPOSITS ---" + "\n-----------------------------------------------------------------------------------------------------" + "------------------------------------------------------" + "\n -> Account No = " + IntegerToString(AccountInfoInteger(ACCOUNT_LOGIN)) + "\n -> Total Cash Deposits = " + DoubleToString(totalDeposits, 2) + AccountInfoString(ACCOUNT_CURRENCY) + "\n-----------------------------------------------------------------------------------------------------" + "------------------------------------------------------" ); } }
Sie können die vollständige GetTotalDeposits.mq5 Datei am Ende dieses Artikels herunterladen.
Eine Anleitung, um einen preisdatengesteuerten Expert Advisor mit der EX5 Bibliothek History Manager zu erstellen
Für das letzte Beispiel in diesem Artikel werden wir einen einfachen, aber leistungsstarken preisdatengesteuerten Expert Advisor namens PriceTrader_EA erstellen, der auf den Bibliotheken PositionsManager.ex5 und HistoryManager.ex5 basiert. Dieser Expert Advisor hat ein erhebliches Gewinnpotenzial, insbesondere wenn er auf einem großen Konto und nach gründlichen Backtests und Optimierungen eingesetzt wird. Sie werden feststellen, dass der Quellcode für PriceTrader_EA dank der Verwendung unserer vorentwickelten Bibliotheken PositionsManager.ex5 und HistoryManager.ex5 übersichtlich und effizient ist. Diese Bibliotheken ermöglichen es uns, den Code zu minimieren und gleichzeitig Zuverlässigkeit und Konsistenz zu gewährleisten.
PriceTrader_EA wurde entwickelt, um Handelsentscheidungen auf der Grundlage von Kursdaten und historischen Handelsergebnissen zu treffen. Es umfasst die folgenden Hauptmerkmale:
- Dynamische Losgrößenbestimmung: Der Expert Advisor passt die Losgrößen auf der Grundlage der Ergebnisse früherer Handelsgeschäfte an und verdoppelt die Losgröße nach einem Verlustgeschäft, um Verluste (innerhalb vordefinierter Grenzen) auszugleichen.
- Handelsrichtung basierend auf der Preisbewegung:PriceTrader_EA eröffnet das Handelsgeschäft in der Richtung des vorherrschenden Trends, der durch die Preisbewegung im H1-Zeitrahmen bestimmt wird.
- Risikomanagement: Stop-Loss (SL) und Take-Profit (TP) werden dynamisch auf der Grundlage des aktuellen Spreads berechnet, um die Anpassungsfähigkeit an sich ändernde Marktbedingungen zu gewährleisten.
Wir beginnen damit, dass wir die Header-Dateien der Bibliotheken HistoryManager.mqh und PositionsManager.mqh in den Header-Bereich unserer Quelldatei aufnehmen.
#include <Wanateki/Toolkit/HistoryManager/HistoryManager.mqh> #include <Wanateki/Toolkit/PositionsManager/PositionsManager.mqh>
Als Nächstes werden wir die Eingabeparameter für PriceTrader_EA definieren. Mit diesen Parametern können wir die magische Zahl, die Spread-Multiplikatoren für TP und SL sowie die maximale Erhöhungder Losgröße konfigurieren.
input ulong magicNo = 101010; input int tpSpreadMulti = 70; input int slSpreadMulti = 90; input int maxLotIncrease = 1000;
Wir werden Schlüsselvariablen initialisieren, um Informationen wie den aktuellen Spread, die Losgröße und die Anzahl der offenen Positionen zu speichern. Diese Variablen werden in der gesamten Logik des Expert Advisors verwendet.
bool eaJustLoaded = true; double spread; int spreadPips; long minSLTP = SymbolInfoInteger(Symbol(), SYMBOL_TRADE_STOPS_LEVEL); long freezeLevel = SymbolInfoInteger(Symbol(), SYMBOL_TRADE_FREEZE_LEVEL); double lotSize; int sl, tp; int totalOpenPositions, totalBuyPositionsOpen, totalSellPositionsOpen; //-- PositionData lastClosedPositionInfo;
In der Funktion OnInit() berechnen wir den aktuellen Spread und initialisieren TP und SL basierend auf den Spread-Multiplikatoren. Wir werden auch einen Ton abspielen, um anzuzeigen, dass PriceTrader_EA erfolgreich geladen wurde.
int OnInit() { //--- spread = SymbolInfoDouble(_Symbol, SYMBOL_ASK) - SymbolInfoDouble(_Symbol, SYMBOL_BID); spread = NormalizeDouble(spread, _Digits); spreadPips = int(spread / _Point); tp = spreadPips * tpSpreadMulti; sl = spreadPips * slSpreadMulti; //-- PlaySound("connect.wav"); //--- return(INIT_SUCCEEDED); }
In der Funktion OnDeinit() löschen wir die Chart-Kommentare und spielen einen Ton ab, um anzuzeigen, dass PriceTrader_EA entladen und aus dem Chart entfernt wurde.
void OnDeinit(const int reason) { //--- Comment(""); PlaySound("disconnect.wav"); }
Die Funktion OnTick() enthält die Kernlogik von PriceTrader_EA. In dieser Funktion werden wir Folgendes tun:
- Wir rufen der aktuellen Losgröße und der Anzahl der offenen Positionen ab.
- Wir prüfen, ob der PriceTrader_EA gerade geladen wurde und eröffnen Sie ein erstes Handelsgeschäft auf der Grundlage der H1-Kursentwicklung.
- Wir passen die Losgröße und die Handelsrichtung auf der Grundlage des Ergebnisses des letzten geschlossenen Handelsgeschäfts an.
- Wir eröffnen aufeinanderfolgende Handelsgeschäfte, um von profitablen Trends zu profitieren oder Verluste auszugleichen.
void OnTick() { //--- lotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN); //-- totalOpenPositions = SymbolPositionsTotal(_Symbol, magicNo); totalBuyPositionsOpen = SymbolBuyPositionsTotal(_Symbol, magicNo); totalSellPositionsOpen = SymbolSellPositionsTotal(_Symbol, magicNo); if(eaJustLoaded && totalOpenPositions == 0) { //-- GetLastClosedPositionData(lastClosedPositionInfo, _Symbol, magicNo); if(lastClosedPositionInfo.ticket > 0 && lastClosedPositionInfo.profit < 0) { if(lastClosedPositionInfo.volume * 2 < lotSize * maxLotIncrease) lotSize = lastClosedPositionInfo.volume * 2; // double lot size } //-- if(iOpen(_Symbol, PERIOD_H1, 0) < iClose(_Symbol, PERIOD_H1, 0)) { OpenBuyPosition(magicNo, _Symbol, lotSize, sl, tp, "Initial_Position"); } else { OpenSellPosition(magicNo, _Symbol, lotSize, sl, tp, "Initial_Position"); } if(totalOpenPositions > 0) eaJustLoaded = false; } else { eaJustLoaded = false; } if(totalOpenPositions == 0 && !eaJustLoaded) { if(GetLastClosedPositionData(lastClosedPositionInfo, _Symbol, magicNo)) { if(lastClosedPositionInfo.profit > 0) // PROFITABLE TRADE { if(lastClosedPositionInfo.type == POSITION_TYPE_BUY) { OpenBuyPosition(magicNo, _Symbol, lotSize, sl, tp, "Consecutive Profit"); } else // SELL POSITION { OpenSellPosition(magicNo, _Symbol, lotSize, sl, tp, "Consecutive Profit"); } } else // LOSS TRADE { if(lastClosedPositionInfo.volume * 2 < lotSize * maxLotIncrease) lotSize = lastClosedPositionInfo.volume * 2; // double lot size //-- if(lastClosedPositionInfo.type == POSITION_TYPE_BUY) { // Reverse trade direction OpenSellPosition(magicNo, _Symbol, lotSize, sl, tp, "Loss Recovery"); } else // SELL POSITION { OpenBuyPosition(magicNo, _Symbol, lotSize, sl, tp, "Loss Recovery"); } } } }
PriceTrader_EA ist ideal für Sie, wenn Sie zu den Händlern gehören, die eine einfache, aber effektive automatische Trendfolgestrategie mit dynamischem Risikomanagement bevorzugen oder benötigen. Dieser EA ist so konzipiert, dass er Verluste durch eine adaptive Losgröße schnell wieder ausgleicht und so sicherstellt, dass Ihre Handelsstrategie auch unter ungünstigen Marktbedingungen stabil bleibt. Darüber hinaus werden Sie feststellen, dass PriceTrader_EA clever kodiert ist, um die Backtests auf MetaTrader 5 so einfach und effizient wie möglich zu gestalten. Die Nutzereingaben für Lotgröße, Stop-Loss und Take-Profit werden automatisch auf der Grundlage des geladenen Symbols angepasst, sodass keine manuellen Anpassungen erforderlich sind und eine optimale Performance für verschiedene Instrumente gewährleistet ist.
Hier finden Sie den kompletten Quellcode vonPriceTrader_EA.mq5 am Ende dieses Artikels, ebenso wie die Bibliothek PositionsManager.ex5.
Backtests des Price Trader Expert Advisors
Lassen Sie uns einen Backtest im MetaTrader 5 Strategietester durchführen, um zu sehen, wie sich diese einfache Handelsstrategie in den letzten vierzehn Monaten entwickelt hat.
Hier sind die Einstellungen, die wir im Strategietester anwenden werden:
-
Broker: Deriv
-
Server: Deriv-Demo
-
Symbol: Volatilität 50 (1s) Index
-
Zeitrahmen: Täglich
-
Testzeitraum (Datum): 1 Jahr, 2 Monate (Jan 2024 bis Feb 2025)
-
Modellierung: Jeder Tick anhand realer Ticks
-
Einzahlung: 5.000 USD
-
Hebel: 1:1000
Einstellungen der Eingänge:
Hier sind die Backtesting-Ergebnisse für den PreisTrader_EA:
Bei der Überprüfung der Ergebnisse unseres Backtests lieferteder PriceTrader_EA einen beeindruckenden Gewinn von über 129% bei einem niedrigen Equity Drawdown von nur 29%. Diese einfache, aber wirksame Strategie weist ein erhebliches Potenzial auf und kann weiter verfeinert und optimiert werden, um noch bessere Ergebnisse zu erzielen. Da PriceTrader_EA seine Eingaben - wie Losgröße, Stop Loss und Take Profit - dynamisch an das gehandelte Symbol oder das gehandelte Handelsinstrument anpasst, können Sie ihn problemlos auf einem Demokonto testen. Laden Sie sie einfach in ein Chart und beobachten Sie die Performance über einen Tag oder mehrere Tage, um zu sehen, ob sie Gewinne erzielt, so wie es bei unseren Strategietester-Evaluierungen der Fall war. Diese Flexibilität macht es zu einem ausgezeichneten Instrument sowohl für Tests als auch für den Live-Handel.
Schlussfolgerung
Wie in diesem letzten Artikel der Serie gezeigt wird, ist die Bibliothek HistoryManager.ex5 ein leistungsfähiges und effizientes Werkzeug, das die Verarbeitung von Handelsverläufen im MetaTrader 5 vereinfacht. Mit ihrer umfassenden Funktionspalette ermöglicht diese Bibliothek den mühelosen Zugriff auf und die Verwaltung von Daten zu Handelsgeschäften, Aufträgen, Positionen und schwebenden Aufträgen - und das alles durch einfache, einzeilige Funktionsaufrufe. Dieser rationalisierte Ansatz spart Zeit und Mühe, sodass Sie sich auf die Entwicklung und Optimierung Ihrer Handelsstrategien konzentrieren können.
In diesem Artikel habe ich praktische Codebeispiele gegeben, die Ihnen helfen sollen, das volle Potenzial der Bibliothek HistoryManager.ex5 auszuschöpfen. Diese Beispiele, kombiniert mit dem in dieser Serie vermittelten Wissen, haben Sie mit den Werkzeugen und Ressourcen ausgestattet, die Sie benötigen, um jede Art von historischen Daten, die aus Ihren Handelsaktivitäten in MetaTrader 5 mit MQL5 generiert wurden, algorithmisch zu verarbeiten. Als Abschiedsgeschenk für alle Leser, die mir gefolgt sind, habe ich PriceTrader_EA entwickelt, einen einfachen, aber effektiven Expert Advisor, der die praktische Anwendung einiger dieser Konzepte zeigt.
Danke, dass Sie mich auf dieser Reise durch die MQL5-Entwicklung begleiten. Ihr Engagement, diese Tools zu erlernen und zu erforschen, zeugt von Ihrem Willen, die Kunst des algorithmischen Handels zu beherrschen. Wie immer wünsche ich Ihnen alles Gute bei Ihrem Bestreben, die Komplexität der Märkte zu entwirren und mit Ihren MQL5-Entwicklungen Erfolg zu haben. Viel Spaß beim Codieren und viel Erfolg für Ihre Strategien!
Ressourcen und Quelldateien
Der gesamte Code, auf den in diesem Artikel verwiesen wird, wird im Folgenden zu Ihrer Information bereitgestellt. Die hier enthaltene Tabelle gibt einen Überblick über die zugehörigen EX5-Bibliotheken und Quellcodedateien, sodass Sie leicht auf die besprochenen Beispiele zugreifen, sie implementieren und untersuchen können.
| Dateiname | Beschreibung |
|---|---|
| HistoryManager.ex5 | EX5-Bibliothek für die Verarbeitung und Verwaltung von Handelsverläufen. |
| PositionsManager.ex5 | EX5-Bibliothek zur Verwaltung und Bearbeitung von Positionen und Aufträgen. |
| HistoryManager.mqh | Header-Datei, die zum Importieren von Datenstrukturen und Prototyp-Funktionen aus der Bibliothek HistoryManager.ex5 in Ihre Quelldateien verwendet wird. |
| PositionsManager.mqh | Header-Datei, die zum Importieren von Prototyp-Funktionen aus der PositionsManager.ex5-Bibliothek in Ihre Quelldateien verwendet wird. |
| GetProfitFactor.mq5 | Expert Advisor, der die Leistung Ihrer Handelsstrategien durch die Berechnung von Schlüsselkennzahlen wie Bruttogewinn, Bruttoverlust und Gewinnfaktor analysiert. |
| GetNetProfitThisWeek.mq5 | Skript zur Berechnung des Nettogewinns für die aktuelle Woche. |
| GetSymbolPipsProfitToLossRatio.mq5 | Expert Advisor, der das Gewinn-Verlust-Verhältnis in Pips für ein bestimmtes Handelssymbol oder einen gesamten Expert Advisor berechnet. |
| GetTotalDeposits.mq5 | Skript, das Handelsgeschäftsdaten abruft und analysiert, um einen klaren Überblick über den Verlauf der Finanzierung oder Bareinzahlung Ihres Kontos zu geben. |
| PriceTrader_EA.mq5 | Ein preisdatengesteuerter Expert Advisor, der Daten aus der Handelshistorie verwendet, um die Preisrichtung zu erkennen und Verluste auszugleichen. Unterstützt von den Bibliotheken PositionsManager.ex5 und HistoryManager.ex5. |
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/17015
Die Übertragung der Trading-Signale in einem universalen Expert Advisor.
Eine Einführung in die Kurven von Receiver Operating Characteristic
Eine alternative Log-datei mit der Verwendung der HTML und CSS
Einführung in MQL5 (Teil 13): Ein Anfängerleitfaden zur Erstellung nutzerdefinierter Indikatoren (II)
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.