Von der Grundstufe bis zur Mittelstufe: Arbeiten mit Dateien in der Sandbox von MetaTrader 5

Einführung

Im vorigen Artikel „Von der Grundstufe zur Mittelstufe: Objektereignisse (IV)“ haben wir erklärt und demonstriert, wie Sie, lieber Leser, eine Methodik entwickeln können, um bestimmte Objekte, die sich auf einem Chart befinden, direkt in der Größe zu ändern. Da das Ziel hier NICHT darin besteht, eine Anwendung zu entwickeln, sondern anhand von Beispielen zu demonstrieren und zu zeigen, wie Sie MQL5 zur Steuerung und Verwaltung von Prozessen in MetaTrader 5 verwenden können, sehe ich an dieser Stelle keinen Grund, tiefer auf das einzugehen, was in jenem Artikel behandelt wurde.

Wir könnten diese Art der Implementierung erheblich erweitern, um noch mehr Funktionalität zu erreichen. Aber in diesem Fall sind meine Interessen und Ziele anders. Daher werden wir mit dem Studium eines anderen Themas beginnen, dessen Verständnis ebenfalls sehr wichtig ist, bevor Sie sich entscheiden, andere programmierbezogene Aktivitäten in Angriff zu nehmen.

Wie üblich werden wir zu einem neuen Thema übergehen und besprechen, worum es in diesem und den nächsten Artikeln gehen wird.

Arbeiten mit Dateien

Ein Thema, das extrem komplex werden kann, je nachdem, was genau Sie tun möchten, ist die Notwendigkeit, mit Dateien zu arbeiten. Obwohl viele Leute dieses Thema für einfach oder sogar trivial halten, wenn man bedenkt, was die meisten aus der Praxis kennen oder üblicherweise sehen, sieht die Realität ganz anders aus, als es auf den ersten Blick scheinen mag.

Die Arbeit mit Dateien ist zweifellos eines der komplexesten und schwierigsten Themen, die es zu beherrschen gilt. Dies liegt an der einfachen Tatsache, dass eine Datei alles enthalten kann. Mehr ist dazu im Grunde nicht zu sagen. Die Dateiverarbeitung wird oft unterschätzt, da die betroffenen Informationen meist in der einfachsten und zugänglichsten Form präsentiert werden.

Da Dateien jedoch binäre Informationen enthalten können – von numerischen Werten oder Anwendungseinstellungen bis hin zum Programm selbst in Form von Objektcode oder Maschinencodes in Form von Opcodes –, ist es nicht verwunderlich, dass dieses Thema sehr schnell extrem komplex werden kann. Dies liegt in erster Linie am internen Format, das eine Datei haben kann.

Um sicherzustellen, dass jeder verstehen und verinnerlichen kann, was wir tun können und wie wir es implementieren, werden wir – zumindest anfangs – ohne Eile mit einem einfacheren Modell beginnen. Wenn Sie die Konzepte dann verinnerlicht und verstanden haben, werden wir zu detaillierteren und komplexeren Themen übergehen können, wobei wir stets versuchen werden, die Erklärung lehrreich zu halten.

Zunächst müssen wir etwas über die MetaTrader 5-Plattform selbst verstehen und genau wissen, wie sie mit Dateien arbeitet. Ja, es gibt Unterschiede zwischen der Verwendung von MetaTrader 5, wenn man alles in reinem MQL5 programmiert, und der Verwendung, wenn ein Teil der Funktionalität außerhalb von MQL5 implementiert ist. Sie müssen dies verstehen, bevor Sie wirklich beginnen, mit Dateien zu arbeiten.

Wenn wir in reinem MQL5 programmieren, um MetaTrader 5 zu steuern oder zu beeinflussen, sind wir auf das beschränkt, was als Sandbox bekannt ist. Der Begriff „Sandbox“ ist heute dank moderner Betriebssysteme weitverbreitet, die es ermöglichen, eine Umgebung zu schaffen, um unbekannte Anwendungen auf relativ sichere Weise auszuführen. Dies liegt daran, dass die Anwendung so dargestellt wird, als könne sie alles tun, was sie will, während alle Änderungen auf die Sandbox beschränkt bleiben und verworfen werden, sobald diese Sandbox geschlossen wird.

Dies stellt sicher, dass selbst eine potenziell schädliche Anwendung weder Dateien beschädigt noch das Betriebssystem zum Absturz bringt. Mit anderen Worten: Eine Sandbox ist ein sicherer Bereich, außerhalb dessen nichts beeinträchtigt wird.

MetaTrader 5 arbeitet nach einem ähnlichen Prinzip. Bei der Verwendung von reinem MQL5 haben wir eine Standard-Sandbox. Wenn wir jedoch Programme von Drittanbietern oder sogar DLL-Bibliotheken verwenden, können wir möglicherweise die MetaTrader 5-Sandbox umgehen oder gefährden. Dies ermöglicht den Zugriff auf Bereiche des Datenträgers oder des Dateisystems, die außerhalb der MetaTrader 5-Sandbox liegen. „Aber Moment, wäre das nicht gut? Schließlich könnten wir Daten auf Geräte oder in Bereiche des Dateisystems schreiben, auf die wir normalerweise nicht zugreifen können.“

Nun, das ist ein ziemlich komplexes Thema, das an dieser Stelle zu erklären ist, lieber Leser. Der Zugriff auf Bereiche außerhalb der Sandbox hat seine Vor- und Nachteile. Für den Moment sollten Sie jedoch verstehen, dass dies gefährlicher als nützlich ist. Wenn eine in MetaTrader 5 ausgeführte Anwendung Zugriff außerhalb der Sandbox erhält, kann sie auf Dinge zugreifen, auf die sie eigentlich nicht zugreifen können sollte. In vielen Fällen kann dies die Integrität all Ihrer Dateien gefährden.

Bedenken Sie, dass Sie eine Anwendung ausführen, die in einem finanziell sensiblen Umfeld arbeitet. Ohne die gebotene Sorgfalt könnten Sie in MetaTrader 5 eine Anwendung ausführen, die letztendlich Zugriff auf einige Ihrer Dateien erhält, obwohl sie aufgrund der Sandbox-Beschränkungen eigentlich keinen Zugriff darauf haben sollte. Damit dies jedoch tatsächlich geschieht, müssen Sie als Benutzer der Anwendung die Erlaubnis dazu erteilen.

Dies geschieht normalerweise, wenn Sie die in der folgenden Abbildung gezeigte Option aktivieren:

Abbildung 01

Abbildung 01 zeigt den entscheidenden Punkt, der es einer Anwendung ermöglichen kann, während sie in MetaTrader 5 ausgeführt wird, die Sandbox zu verlassen. Es gibt sogar eine Warnung, dass die Aktivierung dieser Option für das System gefährlich sein kann. Dies liegt genau an den Risiken, die mit der Manipulation von Dateien ohne ordnungsgemäße Kontrolle durch MetaTrader 5 verbunden sind. Sobald die Sandbox verlassen wurde, kann MetaTrader 5 nicht mehr kontrollieren, was geschieht. In diesem Fall liegt die Kontrolle in den Händen der Anwendung und möglicherweise bei Aufrufen der DLL-Bibliotheken des Betriebssystems. Obwohl dies sicher erscheinen mag, kann eine bösartige Anwendung die DLL-Bibliotheken des Betriebssystems selbst nutzen, um katastrophale Schäden zu verursachen. SEIEN SIE DAHER VORSICHTIG.

„In Ordnung, aber wie schützt uns die Sandbox in solchen Fällen?“ Hier wird es am interessantesten, lieber Leser. Die Entwickler von MetaTrader 5 verfolgten einen sehr zukunftsorientierten Ansatz, indem sie alles in kleine Blöcke unterteilten, von denen jeder als separate, vollständig von den anderen isolierte Sandbox betrachtet werden kann. In der Praxis ist es jedoch nicht ganz so einfach. Ein detailliertes Verständnis dieser Prozesse wird jedoch mit der Zeit kommen, wenn Sie die gezeigten Methoden und Materialien in die Praxis umsetzen.

In der Anfangsphase werden wir ausschließlich innerhalb der Sandbox arbeiten, auf die einfachste Art und Weise und ohne unnötige Komplikationen. Dies wird es uns ermöglichen, Dateien und Verzeichnisse ohne unnötigen Stress oder das Risiko eines Datenverlusts zu erstellen und zu ändern. Die Sandbox wurde genau für diesen Zweck entwickelt.

In Ordnung, lassen Sie uns also mit etwas sehr Einfachem und leicht Verständlichem beginnen. Dies lässt sich mit dem folgenden Code umsetzen.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const string szText = "This file was created by a script written in MQL5.";
07.     uchar info[];
08. 
09.     StringToCharArray(szText, info);
10. 
11.     FileSave("Hello.txt", info);
12. }
13. //+------------------------------------------------------------------+

Code 01

Dies ist ein sehr einfacher und unkomplizierter Code zum Schreiben von Dateien. Wenn dieser Code jedoch ausgeführt wird, passiert etwas, das Sie vielleicht ein wenig neugierig macht. Aber lassen Sie uns einen Schritt nach dem anderen tun. Zunächst enthält Zeile 06 von Code 01 die Nachricht, die in die Datei geschrieben wird. Aber in welche Datei genau? „In Ordnung, der Dateiname ist in Zeile 11 angegeben, aber wo wird diese Datei gespeichert?“ Oder genauer gesagt: In welchem Verzeichnis auf dem Datenträger sollte ich nach dieser Datei suchen oder sie erwarten?“ Nun, das hängt von bestimmten Bedingungen ab. So wie der Code geschrieben ist, wird er im Standardverzeichnis der Sandbox von MetaTrader 5 gespeichert.

Der genaue Ort in der Verzeichnisstruktur hängt davon ab, ob Sie den Code in MetaTrader 5 oder in einem Test-Agenten ausführen. Nehmen wir auf jeden Fall an, dass der gesamte Code direkt in MetaTrader 5 ausgeführt wird. In diesem Fall wird die Datei im Unterordner MQL5\Files gespeichert. Dies ist auf der folgenden Abbildung zu sehen:

Abbildung 02

Nun können Sie in Abbildung 02 sehen, dass der Pfeil auf ein seltsames Zeichen zeigt. Dieses Zeichen ist Teil der Datei, da es darin gespeichert wurde. Wenn wir uns jedoch die Nachricht in Zeile 06 ansehen, ist dieses Zeichen dort nicht zu erkennen. Woher kommt es also? Nun, lieber Leser, dieses Zeichen ist aufgrund von Zeile 09 erschienen. Da wir den String in ein Zeichen-Array umwandeln, damit die Funktion in Zeile 11 den String in eine Datei schreiben kann, wird auch das Zeichen für das Stringende Teil des gespeicherten Inhalts, da es nicht aus dem in das Array umgewandelten String entfernt wurde.

In Ordnung, aber wird dies zu Problemen führen? Im Prinzip wäre dies kein Problem, wenn Sie wüssten, dass es existiert. Da Code 01 jedoch sehr einfach ist und nur als erste Einführung in das Dateisystem gedacht ist, sehe ich keinen Grund, sich in diesem Stadium darüber Sorgen zu machen.

Um also zu beweisen, dass der in Abbildung 02 gezeigte Inhalt mit diesem seltsam aussehenden Zeichen in der Datei in diesem Stadium kein Problem für uns darstellt, werden wir Code 01 so modifizieren, dass er die geschriebene Datei liest und dann ihren Inhalt auf dem Terminal ausgibt. Dies ist in Code 02 unten zu sehen.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06. #define szFileName "Hello.txt"
07. 
08.     const string szText = "This file was created by a script written in MQL5.";
09. 
10.     uchar W[], R[];
11. 
12.     StringToCharArray(szText, W);
13. 
14.     FileSave(szFileName, W);
15. 
16.     FileLoad(szFileName, R);
17. 
18.     Print(CharArrayToString(R));
19. }
20. //+------------------------------------------------------------------+

Code 02

Um sicherzustellen, dass wir dieselbe Datei lesen, die wir schreiben, verwenden wir die Definition in Zeile 06 von Code 02, um den Namen der verwendeten Datei anzugeben. Da die ersten Zeilen bereits erklärt wurden, können wir zu Zeile 16 übergehen. Hier lesen wir den Inhalt der Datei und legen ihn in einem Array ab. In Zeile 18 wandeln wir dieses Zeichen-Array in einen String um, was es uns ermöglicht, dieselbe Nachricht wie in Zeile 08 auszugeben.

Um dies zu überprüfen, können wir bei der Ausführung von Code 02 das folgende Ergebnis sehen:

Abbildung 03

Mit anderen Worten: Alles hat wie erwartet funktioniert. Dies ist der einfachste mögliche Fall, bei dem wir mit einem minimalen Codeaufwand den Inhalt einer Datei speichern und anschließend lesen können, ohne unnötigen Stress oder Komplikationen.

Lassen Sie uns die Aufgabe nun etwas komplexer gestalten, damit Sie beginnen können, bestimmte Nuancen beim Lesen und Schreiben von Dateien zu verstehen. Zunächst einmal ändern wir die Sandbox. Dazu müssen wir lediglich den oben gezeigten Code durch den folgenden Code ersetzen:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06. #define szFileName "Hello.txt"
07. 
08.     const string szText = "This file was created by a script written in MQL5.";
09. 
10.     uchar W[], R[];
11. 
12.     StringToCharArray(szText, W);
13. 
14.     FileSave(szFileName, W, FILE_COMMON);
15. 
16.     FileLoad(szFileName, R, FILE_COMMON);
17. 
18.     Print(CharArrayToString(R));
19. }
20. //+------------------------------------------------------------------+

Code 03

Wenn Sie Code 03 ausführen, werden Sie dasselbe Ergebnis wie in Abbildung 03 sehen. Wenn Sie jedoch versuchen, diese Datei zu finden, werden Sie feststellen, dass sie nicht im Unterordner MQL5\Files erstellt wird; sie wird woanders erstellt. Aber wo? Bevor wir das besprechen, beachten Sie bitte, dass der einzige Unterschied zwischen Code 02 und Code 03 genau der zusätzliche Parameter ist, der in den Zeilen 14 und 16 hinzugefügt wurde, wie Sie in Code 03 sehen können.

Passen Sie jetzt gut auf, liebe Leserin, lieber Leser. Beim Speichern der Datei in Zeile 14 teilt dieser zusätzliche Parameter MetaTrader 5 mit, in welcher Sandbox die Datei gespeichert wird. Wenn dieser Parameter jedoch beim Lesen, was in Zeile 16 geschieht, nicht angegeben wird, sucht MetaTrader 5 die Datei in der Standardsandbox, also im Unterordner MQL5\Files. Dies kann zu einem Ergebnis führen, das von dem erwarteten abweicht: ein Fehler beim Lesen oder Zugriff auf die Datei oder in einigen Fällen ein unverständlicher Inhalt, der stark von dem abweicht, was wir erwartet haben.

Damit der gesamte Prozess korrekt funktioniert, müssen die Speicherorte beim Lesen und Schreiben übereinstimmen. Es ist sinnlos, beim Schreiben eine Sandbox und beim Lesen eine andere anzugeben oder umgekehrt. Es ergibt keinen Sinn, zu erwarten, dass MetaTrader 5 versteht, was Sie zu tun versuchen oder auf welche Datei Sie zuzugreifen versuchen. Es ist dazu nicht verpflichtet und hat auch kein Interesse daran.

Obwohl es in einigen Fällen die richtige Datei finden mag, sollten Sie sich nicht darauf verlassen. Höchstwahrscheinlich werden Sie am Ende eine Datei am falschen Ort schreiben oder lesen. Dies könnte nicht nur Ihre Erwartungen hinsichtlich der Art der benötigten Informationen nicht erfüllen, sondern auch Daten beschädigen, die bereits in einer Datei vorhanden waren, die aufgrund Ihres Fehlers mit neuen Daten überschrieben wurde.

Jetzt können wir also endlich versuchen zu verstehen, auf welche Sandbox dieser zusätzliche Parameter in den Zeilen 14 und 16 von Code 03 genau verweist. Dies ist notwendig, damit Sie die Datei bei Bedarf auch mit jedem anderen Editor finden können. Der Parameter FILE_COMMON weist MetaTrader 5 an, den Unterordner \Terminal\Common\Files zu verwenden. Es ist ganz einfach. „Warten Sie einen Moment, lassen Sie mich verstehen, was hier passiert. Wenn der Parameter FILE_COMMON fehlt, verweisen wir auf die Sandbox MQL5\Files, und wenn er vorhanden ist, verweisen wir auf die Sandbox \Terminal\Common\Files. Ist das alles?“ Ja, lieber Leser, genau das passiert. „Aber ich bin davon ausgegangen, dass wir ein Verzeichnis angeben müssten, damit diese Änderung wirksam wird. In gewisser Weise erscheint mir das etwas verwirrend.“

Tatsächlich ist es gar nicht so kompliziert, lieber Leser. Es mag genau deshalb so scheinen, weil Sie das Konzept einer Sandbox noch nicht verstehen. Aber lassen Sie uns nicht hetzen, damit Sie dieses Konzept vollständig aufnehmen und in einer Vielzahl von Situationen verwenden können. Das korrekte Verständnis dieses Prozesses ist sehr wichtig, wenn Sie in vielen verschiedenen Situationen das Beste aus MetaTrader 5 herausholen wollen.

Verstehen der Sandbox

Um das Konzept einer Sandbox richtig zu verstehen, brauchen wir eine Vorstellung davon, wie das Dateisystem funktioniert. Ich werde eine kurze Erklärung geben, damit die später verwendeten Begriffe für diejenigen klar sind, die noch nicht mit ihnen vertraut sind.

Der erste Begriff, den Sie verstehen müssen, ist das Konzept eines Roots oder Stammverzeichnisses. Das Stammverzeichnis kann man sich als den Ausgangspunkt in einem Verzeichnisbaum vorstellen. Die Baumidee beruht auf der Tatsache, dass jeder Ast des Baumes einem Unterordner innerhalb desselben Verzeichnisses entspricht. Jedes Blatt an einem dieser Äste entspricht einer Datei. Der Einfachheit halber ist das Root also das anfängliche Verzeichnis. Jeder Verzeichnisbaum hat genau ein Stammverzeichnis. Von diesem Stammverzeichnis aus haben wir zunächst einen Ast. Jedes Blatt an diesem Ast ist eine Datei, die direkt mit dem Stammverzeichnis verbunden ist. Ein Baum hat KEINEN direkten Kontakt zu einem anderen Baum. Mit anderen Worten: Es ist KEIN Baum mit zwei verschiedenen Stammverzeichnissen. Und alle stehen auf demselben Untergrund.

Nachdem wir dies verstanden haben, können wir eine visuelle Analogie dazu ziehen, wie die Sandbox in MetaTrader 5 organisiert ist. Dies wird in der folgenden Abbildung gezeigt:

Abbildung 04

Abbildung 04 zeigt zwei Sandboxes, genau wie die, die wir im vorherigen Abschnitt verwendet haben. Beachten Sie, dass der Basisordner der Unterordner MetaQuotes\Terminal ist. Es ist jedoch NICHT DIE WURZEL, sondern die Basis, auf der diese Bäume platziert sind.

Achten Sie nun auf Folgendes: Baum Nr. 1 hat ein Stammverzeichnis, das sich in diesem Fall im Ordner Common\Files befindet. Baum Nr. 2 hat ein anderes Stammverzeichnis, das sich im Ordner MQL5\Files befindet. Beachten Sie, dass wir nicht direkt von einem Baum zum anderen wechseln können, ohne zuerst die zugrunde liegende Basis zu durchlaufen. Normalerweise würde der Wechsel von einem Zweig zum anderen erfordern, die zugrunde liegende Basis zu durchlaufen. Diese Art des Übergangs kann hier jedoch nicht verwendet werden, da ein Baum eine Sandbox ist, während der andere Baum eine andere Sandbox ist.

Um dies etwas klarer zu machen und Ihnen gleichzeitig die Möglichkeit zu geben, zu studieren und zu versuchen zu verstehen, wie all dies implementiert werden kann, werden wir den im vorherigen Abschnitt besprochenen Code so ändern, dass wir unserem Zweig Verzeichnisse hinzufügen können. Dies ist sehr einfach umzusetzen, aber die Ergebnisse sind recht interessant und können Ihnen helfen, zu verstehen, wie die Sandbox in der Praxis funktioniert. Dies ist notwendig, um alles unter Kontrolle zu halten. Nachfolgend finden Sie den Code, den wir zu Beginn verwenden werden:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06. #define szFileName "Hello.txt"
07. #define macro_Save(A) Print("Attempting to write in [",A,"] resulted in: ", FileSave(A, buff));
08. //+----------------+
09.     const string szText = "This file was created by a script written in MQL5.\nThis would be the contents of file number #%02d.";
10. //+----------------+
11.     uchar   buff[];
12.     ushort  counter = 1;
13. //+----------------+
14.     StringToCharArray(StringFormat(szText, counter++), buff);
15.     macro_Save(szFileName);
16. //+----------------+
17.     StringToCharArray(StringFormat(szText, counter++), buff);
18.     macro_Save(".\\Test\\" + szFileName);
19. //+----------------+
20.     StringToCharArray(StringFormat(szText, counter++), buff);
21.     macro_Save(".\\Temp\\" + szFileName);
22. //+----------------+
23.     StringToCharArray(StringFormat(szText, counter++), buff);
24.     macro_Save("..\\SandBox\\" + szFileName);
25. }
26. //+------------------------------------------------------------------+

Code 04

In Code 04 werden wir versuchen, vier verschiedene Dateien in verschiedene Zweige innerhalb der MQL5\Files-Sandboxen zu schreiben. Bei einem dieser Versuche werden wir jedoch versuchen, die Sandbox zu verlassen und Daten in das MQL5-Verzeichnis zu schreiben. Lassen Sie uns dies langsam untersuchen, damit Sie verstehen können, wie diese Versuche durchgeführt wurden und wie ihre Ergebnisse zu interpretieren sind.

Zunächst einmal werden wir beim Ausführen von Code 04 in MetaTrader 5 ein Ergebnis im Terminal sehen, das dem unten Gezeigten ähnelt:

Abbildung 05

Beachten Sie, dass in drei Fällen die Dateiinhalte korrekt geschrieben wurden. Obwohl wir keine Verzeichnisse mit anderen Aufrufen erstellt hatten, erkannte MetaTrader 5 die Notwendigkeit, zwei neue Verzeichnisse zu erstellen, falls diese vor der Ausführung von Code 04 noch nicht existierten.

Lassen Sie uns nun betrachten, welche Art von Inhalt in die Dateien geschrieben wurde und wo sie sich befinden. Dies ist auf den folgenden Abbildungen zu sehen:

Abbildung 06

Abbildung 07

Abbildung 08

Bitte beachten Sie, dass wir in diesen drei Abbildungen den Speicherort und den Dateinamen grün markiert haben. Aber schauen Sie sich den Inhalt jeder einzelnen Datei genau an. Sie werden sehen, dass sie fast identisch sind, bis auf den numerischen Wert in der zweiten Zeile. Dieser Wert dient nur dazu, den Inhalt der Dateien zu unterscheiden und zu zeigen, dass wir verschiedene Dateien auf die gleiche Weise schreiben können.

Kommen wir jedoch zurück zu Code 04 selbst. Beachten Sie, dass wir in den Zeilen 15, 18, 21 und 24 nur den Namen des verwendeten Verzeichnisses ändern. Wie in Abbildung 05 gezeigt, trat jedoch ein Fehler beim Versuch auf, die vierte Datei zu erstellen. Warum? Der Grund dafür ist, dass wir versuchen, etwas außerhalb der aktuellen Sandbox zu erstellen. Mit anderen Worten: Wir versuchen, in einen Zweig zu wechseln, der außerhalb des Sandbox-Stammverzeichnisses liegt. Wenn wir versuchen, dies zu tun, interpretiert MetaTrader 5 dies als Fehler und blockiert alle Operationen auf dem Datenträger, egal ob es sich um das Schreiben oder Lesen des Inhalts einer Datei handelt.

Ich verstehe, dass dies für viele Leute etwas seltsam erscheinen mag. Der einzige Unterschied zwischen den Zeilen 18, 21 und 24 ist der zusätzliche Punkt in Zeile 24, aber er weist das System an, sich in eine andere Richtung als den aktuellen Speicherort zu bewegen. Da wir uns jedoch innerhalb einer Sandbox befinden und MetaTrader 5-Aufrufe über MQL5 verwenden, ist es uns nicht gestattet, die Sandbox zu verlassen. Dies würde nicht passieren, wenn wir eine Schreibfunktion des Betriebssystems selbst verwenden würden. In diesem Fall wüsste das Betriebssystem nichts von der Sandbox, die von MetaTrader 5 erstellt und verwaltet wird. Daher wäre es außerhalb der Sandbox möglich, jede Datei zu schreiben, zu lesen und sogar alles Mögliche damit zu tun.

Da ich das, was vielleicht Ihre erste Einführung in das MetaTrader 5-Dateisystem ist, nicht zu kompliziert machen möchte, werden wir eine letzte Änderung am Code vornehmen, damit Sie das Lesen einiger der Dateien testen können, die unsere Anwendung schreibt.

Hierfür verwenden wir den unten stehenden Code:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06. #define szFileName "Hello.txt"
07. #define macro_Save(A) Print("Attempting to write in [",A,"] resulted in: ", FileSave(A, buff));
08. #define macro_Load(A) Print("Attempt to read the [",A,"] file resulted in: ", FileLoad(A, buff) != INVALID_HANDLE);
09. //+----------------+
10.     const string szText = "This file was created by a script written in MQL5.\nThis would be the contents of file number #%02d.";
11. //+----------------+
12.     uchar   buff[];
13.     ushort  counter = 1;
14. //+----------------+
15.     StringToCharArray(StringFormat(szText, counter++), buff);
16.     macro_Save(szFileName);
17. //+----------------+
18.     StringToCharArray(StringFormat(szText, counter++), buff);
19.     macro_Save(".\\Test\\" + szFileName);
20. //+----------------+
21.     StringToCharArray(StringFormat(szText, counter++), buff);
22.     macro_Save(".\\Temp\\" + szFileName);
23. //+----------------+
24.     StringToCharArray(StringFormat(szText, counter++), buff);
25.     macro_Save("..\\SandBox\\" + szFileName);
26. //+----------------+
27.     Print("+----------------+");
28.     ArrayResize(buff, 0);
29.     macro_Load(".\\Test\\" + szFileName);
30.     if (buff.Size() > 0)
31.         Print("File content:\n", CharArrayToString(buff));
32.     Print("+----------------+");
33.     ArrayResize(buff, 0);
34.     macro_Load(".\\Test 1\\" + szFileName);
35.     if (buff.Size() > 0)
36.         Print("File content:\n", CharArrayToString(buff));
37. }
38. //+------------------------------------------------------------------+

Code 05

Code 05 wird Ihnen helfen, zu verstehen, wie das Sandbox-System funktioniert. Zumindest ist das sein ursprünglicher Zweck. Darin versuchen wir, den Inhalt einer beliebigen Datei an einem bestimmten Ort sowohl zu schreiben als auch zu lesen. Obwohl dies verwirrend erscheinen mag, ist alles einfach, wenn Sie den Stoff vom Anfang des Artikels verinnerlicht haben, wie in der Abbildung gezeigt.

Abbildung 09

Um all diese Meldungen zu verstehen, müssen Sie verstehen, was wir in Code 04 implementiert haben und welches Ergebnis wir erzielen konnten. Da das Ergebnis der Ausführung von Code 04 Abbildung 05 ist und der Inhalt jeder Datei in den Abbildungen 06, 07 und 08 zu sehen ist, müssen wir hier in Code 05 nur einige wichtige Punkte berücksichtigen. Im Wesentlichen müssen wir nur erklären, was ab Zeile 26 passiert. Dort beginnt das Lesen oder der Versuch, Dateien zu lesen.

Wie Sie sehen können, führen wir in den Zeilen 29 und 34 das Makro aus Zeile 08 aus. Das wichtige Detail hierbei ist, dass bei der Ausführung dieses Makros in Zeile 08 eine Meldung im Terminal ausgegeben wird, die angibt, welche Datei wir zu lesen versuchen und ob das Ergebnis erfolgreich war. Bis zu diesem Punkt ist alles ganz normal und leicht verständlich. Aber warum werden in diesem Code die Zeilen 28 und 33 verwendet? Der Grund ist genau das Löschen des Daten-Arrays. Da bei einem Leseversuch ein Fehler auftreten kann, möchten wir nicht, dass frühere Daten erhalten bleiben. Wenn daher die Prüfungen in den Zeilen 30 und 35 ausgeführt werden, geben wir nur dann eine Meldung im Terminal aus, wenn das Array tatsächlich Daten enthält.

Da wir in Zeile 34 versuchen werden, eine Datei zu lesen, die im Prinzip NICHT EXISTIEREN SOLLTE, wird eine Fehlermeldung im Terminal ausgegeben und die Prüfung in Zeile 35 schlägt ebenfalls fehl.

Denken Sie zunächst daran, dass weder die Dateien noch die Verzeichnisse, die in Code 05 angegeben sind, anfänglich existieren sollten. Auf diese Weise ist das Ergebnis korrekt und wird ordnungsgemäß angezeigt, wie in Abbildung 09 dargestellt. Wenn Sie ein anderes Ergebnis erhalten, versuchen Sie, den Namen oder sogar die in Code 05 verwendeten Verzeichnisse zu ändern. Das Ziel ist es, sowohl den Fehler zu erzeugen, der beim Versuch auftritt, eine nicht existierende Datei zu lesen, als auch das Ergebnis des Versuchs, eine Datei in einem bestimmten Verzeichnis zu lesen.

Versuchen Sie auch, den Code so zu ändern, dass die andere in diesem Artikel besprochene Sandbox verwendet wird, d. h. durch Hinzufügen des zusätzlichen Parameters FILE_COMMON. Dies hilft Ihnen, genau zu verstehen, was in Abbildung 04 dargestellt ist, wo zwei Bäume mit unterschiedlichen Stammverzeichnissen angezeigt werden.

Abschließende Überlegungen

In diesem Artikel haben wir unsere ersten Schritte bei der Untersuchung des MetaTrader 5-Dateisystems unternommen, um zu verstehen, wie die Sandbox funktioniert, und um zu vermeiden, versehentlich ungeeignete Ordner im Verzeichnisbaum des Betriebssystems zu ändern. Trotz ihrer anfänglichen Komplexität, insbesondere aus der Sicht eines Anfängers, ist das Verständnis der Verwendung der Sandbox für zukünftige Projekte absolut notwendig. Dies ist besonders wichtig, wenn Sie wirklich aktiv Dateien zum Speichern von Daten verwenden oder sogar Konfigurationen erstellen möchten, die im Laufe der Zeit gespeichert und angepasst werden.

Versuchen Sie, dieses Material ohne Eile zu studieren, lieber Leser, denn dieser Schritt muss korrekt ausgeführt werden. Wenn Sie nicht verstehen, wie die Sandbox funktioniert, wird es für Sie sehr schwierig sein, bestimmte Aufgaben in der Zukunft zu lösen.

MQ5-Datei	Beschreibung
Code 01	Demonstration des Dateizugriffs
Code 02	Demonstration des Dateizugriffs
Code 03	Demonstration des Dateizugriffs
Code 04	Demonstration des Dateizugriffs
Code 05	Demonstration des Dateizugriffs