Marktsimulation (Teil 17): Sockets (XI)

Einführung

In den beiden vorangegangenen Artikeln haben wir erklärt, wie man Excel für die Interaktion mit MetaTrader 5 vorbereitet. Im vorangegangenen Artikel „Marktsimulation (Teil 16): Sockets (X)“ haben wir erklärt, wie man Code in VBA schreibt. Dies ist für eine korrekte Interaktion zwischen Excel und dem in Python geschriebenen Server erforderlich, auch wenn es Ihnen vielleicht so vorkommt, als ob eine solche Interaktion keine Probleme verursachen würde.

In dem kurzen Abschnitt, in dem wir erklärt haben, was Sockets sind, haben wir gezeigt, dass es zu Problemen kommen kann, wenn Excel nicht korrekt eingesetzt wird. Das tritt bei der Verwendung eines in Python geschriebenen Servers auf. Wie jedoch bereits in den beiden vorangegangenen Artikeln gezeigt wurde, löst richtig geschriebener VBA-Code Interaktionsprobleme zwischen Excel und Python und sorgt für eine reibungslose Koordination zwischen ihnen. Für die vollständige Implementierung fehlt jedoch noch ein weiterer Schritt. Dies muss im Abschnitt zu MetaTrader 5 erfolgen, in dem wir mehrere Entscheidungen treffen müssen.

Planung vor der Implementierung

Die wichtigste Entscheidung ist, welche Programmiersprache wir für den in MetaTrader 5 laufenden Teil verwenden. Ich erwähne dies, weil wir es entweder mit Python oder mit MQL5 selbst machen können. Mit beiden Sprachen können wir das meiste, wenn nicht sogar alles machen, was wir wollen. Wenn wir uns jedoch für Python entscheiden, sind wir dadurch eingeschränkt, dass Python, da es sich um ein Skript handelt, an einen Chart gebunden werden muss. Entscheiden wir uns hingegen für MQL5, können wir Methoden oder Modelle nutzen, die für die jeweilige Aufgabe am besten geeignet sind.

Aber wenn wir MQL5 verwenden wollen, können wir die Lösung auf einen Service ausrichten. Mit anderen Worten: Im Gegensatz zu Python, das ein geöffnetes Chart für den Betrieb benötigt, ermöglicht MQL5 die Verwendung eines Service für die Kommunikation mit Excel. Dieser Ansatz hat mehrere Vorteile, die ich bestätigen kann.

Der Hauptvorteil besteht darin, dass der Service unabhängig arbeitet und mit Charts interagieren kann, sodass sich MetaTrader 5 damit nahezu vollständig steuern lässt oder sogar überhaupt nicht mit ihm interagiert. Mit Hilfe eines Service können wir Charts öffnen und schließen, ihnen Elemente hinzufügen, laufende Prozesse ändern und so weiter. Das Wichtigste ist jedoch, dass der Service außerhalb des Charts funktioniert und daher auch dann genutzt werden kann, wenn MetaTrader 5 für Zwecke verwendet wird, die nicht direkt mit dem Markt zusammenhängen.

Ja, MetaTrader 5 kann für mehr als nur den Handel mit Finanzinstrumenten verwendet werden. Wir können dies ein anderes Mal erklären – aber nur, wenn ich es für wirklich interessant halte, es zu demonstrieren. In Ordnung, einverstanden. Wir werden MQL5 verwenden und sicherstellen, dass der Teil des Codes, der im MetaTrader 5 läuft, als Service funktioniert. Lassen Sie uns nun zur Implementierung übergehen.

Implementierung

Die Implementierung des Teils des Codes, der in MetaTrader 5 ausgeführt werden soll, ist unproblematisch. Es gibt jedoch einige Punkte, die berücksichtigt werden müssen. Das ist notwendig, damit das System korrekt funktioniert. Denken Sie an einen wichtigen Punkt: Es läuft nicht nur ein einziges Programm. Tatsächlich müssen drei Programme gleichzeitig ausgeführt werden. In Wirklichkeit müssen drei Programme gleichzeitig laufen. Es ist wichtig, sie so zu implementieren und zu strukturieren, dass sie miteinander interagieren und kommunizieren können und dass jedes von ihnen versteht, was die anderen tun oder beabsichtigen. Daher ist es sehr wichtig, das System Schritt für Schritt zu testen.

Zunächst erstellen wir den Python-Code, der als Server fungieren wird. Als Nächstes werden wir den VBA-Code erstellen und testen, der in Excel ausgeführt wird. Erst wenn Excel effektiv mit dem Python-Server interagieren und ihm Befehle senden kann, sollten wir zu dieser Phase in MetaTrader 5 übergehen.

Daher rate ich Nutzern, die ein ähnliches System erstellen oder einführen wollen und noch nicht viel Erfahrung mit der gleichzeitigen Arbeit mit mehreren Programmen haben, schrittweise vorzugehen. Versuchen Sie nicht, alles auf einmal umzusetzen. Zuerst müssen Sie einen Plan machen und dann Schritt für Schritt vorgehen. Werfen wir also einen Blick auf den Quellcode, den Sie unten vollständig sehen können:

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property version   "1.00"
05. //+------------------------------------------------------------------+
06. input string   user01 = "127.0.0.1";    //Address Server
07. input int      user02 = 9090;           //Port Server
08. //+------------------------------------------------------------------+
09. #define def_SizeBuff     2048
10. //+------------------------------------------------------------------+
11. void OnStart()
12. {
13.     bool tab;
14.     int sock;
15.     uint len, id, iMem;
16.     char buff[], ArrMem[];
17.     string szMsg, szCmd, szRet;
18.     
19.     sock = INVALID_HANDLE;
20.     ArrayResize(ArrMem, def_SizeBuff);
21.     while (!IsStopped())
22.     {
23.         Print("Trying to connect...");
24.         while (!IsStopped())
25.         {
26.             if (sock != INVALID_HANDLE)
27.                 SocketClose(sock);
28.             if ((sock = SocketCreate()) != INVALID_HANDLE)
29.                 if (SocketConnect(sock, user01, user02, 1000))
30.                     break;
31.                 else
32.                     Sleep(500);
33.         }
34.         if (!IsStopped())
35.         {
36.             szMsg = "<MT5 with Excel>:MT5";
37.             len = StringToCharArray(szMsg, buff) - 1;
38.             SocketSend(sock, buff, len);
39.             Print("Excel is online...");
40.         }
41.         ArrayInitialize(ArrMem, 0);
42.         iMem = 0;
43.         while (!IsStopped() && SocketIsConnected(sock))
44.         {
45.             szCmd = szRet = "";
46.             id = 0;
47.             do
48.             {
49.                 len = SocketIsReadable(sock);
50.                 len = ((iMem + len) < def_SizeBuff ? len : def_SizeBuff - iMem);
51.                 if (SocketRead(sock, buff, len, 500) > 0)
52.                     ArrayInsert(ArrMem, buff, iMem);
53.                 for (int c0 = 0; (ArrMem[c0] != 0) && (c0 < def_SizeBuff); c0++) switch (ArrMem[c0])
54.                 {
55.                     case '[':
56.                         id = 1;
57.                     case ';':
58.                         if ((SymbolExist(szMsg, tab)) && (id < 2))
59.                             szRet += StringFormat("%f%s", iClose(szMsg, PERIOD_D1, 0), (ArrMem[c0] == ';' ? ";" : ""));
60.                         szMsg = "";
61.                         break;
62.                     case ']':
63.                         id = 2;
64.                         iMem = 0;
65.                         break;
66.                     default:
67.                         switch (id)
68.                         {
69.                             case 0:
70.                                 szMsg += StringFormat("%c", ArrMem[c0]);
71.                                 break;
72.                             case 1:
73.                                 szCmd += StringFormat("%c", ArrMem[c0]);
74.                                 break;
75.                             case 2:
76.                                 for (iMem = 0; (ArrMem[c0 + iMem] != 0) && ((c0 + iMem) < def_SizeBuff); iMem++);
77.                                 ArrayCopy(ArrMem, ArrMem, 0, c0, iMem);
78.                                 break;
79.                     }
80.                 }
81.             }while (SocketIsConnected(sock) && (!IsStopped()) && (id != 2));
82.             if (!IsStopped() && SocketIsConnected(sock))
83.             {            
84.                 if (szCmd != "")
85.                 {
86.                     Print(szCmd, "<CMD<");
87.                     szRet = "N/D";
88.                 }
89.                 len = StringToCharArray(szRet, buff) - (szCmd != "" ? 1 : 0);
90.                 SocketSend(sock, buff, len);
91.             }
92.         }
93.     }
94.     if (sock != INVALID_HANDLE)
95.         SocketClose(sock);
96.     ArrayFree(ArrMem);
97.     Print("Shutting down...");
98. }
99. //+------------------------------------------------------------------+

Der MQL5-Code

Bevor wir mit der Erläuterung des Codes beginnen, möchte ich klarstellen, dass er ausschließlich für Bildungszwecke gedacht ist. Daher werden wir dieses Thema hier nur kurz behandeln. Glauben Sie nicht, dass dies alles ist, was wir tun können. Wenn Sie jedoch verstehen, was geschieht, können Sie, liebe Leserinnen und Leser, viele interessante Dinge schaffen. Sie können den oben beschriebenen Code als ersten Schritt und als mögliche Referenz verwenden.

Gut, sehen wir uns an, was dieser Code tut. Aber um Sie zu begeistern und zu fokussieren, lassen Sie uns zuerst sehen, was passiert, wenn alles funktioniert. Genau das können Sie unten sehen. Lassen Sie uns zunächst beobachten, was in Excel passiert. Beachten Sie, dass der Service zum Zeitpunkt der Erstellung dieser Animation bereits im MetaTrader 5 lief, was Sie in einer anderen Animation sehen können.

Bei der Beobachtung der MetaTrader 5-Meldungen in Excel während der Ausführung ließen sich die folgenden Abläufe beobachten:

Ein interessantes Ergebnis, nicht wahr? Es sei daran erinnert, dass diese beiden Anwendungen, Excel und MetaTrader 5, auf verschiedenen Computern installiert sein können, und selbst in diesem Fall erhalten wir das gleiche Ergebnis. Nun, da Ihre Neugierde geweckt ist, lassen Sie uns einen Blick darauf werfen, wie dieser Code in MQL5 funktioniert, da die anderen Teile bereits in früheren Artikeln erklärt wurden.

Die Analyse des MQL5-Codes

In der zweiten Zeile geben wir an, dass der Code als Service implementiert ist. Würde diese Zeile fehlen, würde derselbe Code als Skript laufen. In früheren Artikeln haben wir bereits den Unterschied zwischen einem Service und einem Skript erläutert. Aber wenn Sie Zweifel haben, denken Sie daran: Ein Service ist nicht direkt an einen Chart gebunden. Ein Skript hingegen ist an ein Chart gebunden. Der Servicecode und der Skriptcode werden jedoch praktisch identisch sein. Der einzige Unterschied zwischen ihnen ist genau die Zeile 02.

Das nächste, was man verstehen muss, sind die Zeilen 06 und 07. Sie werden verwendet, damit der Nutzer beim Ausführen der ausführbaren Datei in MetaTrader 5 bestimmte Parameter an diese übergeben kann. Dies sind die Parameter, die angepasst werden müssen. Das heißt, die Adresse, unter der der Python-Server läuft, und sein Port.

Bitte beachten Sie Folgendes: Sie müssen nicht den Rechner angeben, auf dem Excel läuft, sondern den Rechner, auf dem der Python-Server läuft. Solche Dinge können Verwirrung stiften. Aber denken Sie daran: Der Python-Server ist in keiner Weise in Excel eingebettet und kann sich auf einem anderen Computer befinden. Aber Excel muss wissen, wie dieser Server erreicht werden kann. Zum besseren Verständnis verweisen wir auf den vorherigen Artikel, in dem wir den Teil des Codes erläutert haben, der in Excel vorhanden und in VBA geschrieben ist.

Nachdem der erste (und grundlegende) Teil abgeschlossen ist, gehen wir zu Zeile 11 über, wo der Hauptteil des Codes beginnt. Zwischen den Zeilen 13 und 17 werden einige Variablen deklariert, die in diesem speziellen Code verwendet werden sollen. Kommen wir nun zu dem Teil, der zunächst etwas verwirrend erscheinen mag, aber später wird alles ganz klar werden. Beachten Sie, dass wir in Zeile 19 eine der Variablen initialisiert haben. Der Grund dafür ist, dass der gesamte Code in einer einzigen großen Schleife enthalten ist. Diese Schleife beginnt in Zeile 21 und geht bis Zeile 93. Die einzige Möglichkeit, sie zu beenden, besteht darin, den Service manuell anzuhalten oder MetaTrader 5 zu schließen.

Um den Zustand unserer Verbindung zum Server festzustellen, werden wir mehrere Meldungen im Nachrichtenfenster des MetaTrader 5 ausgeben, wie bereits in der Animation oben gezeigt. Die erste Meldung wird in Zeile 23 ausgegeben. Darin geben wir einfach an, dass der Client (d. h. MetaTrader 5) versucht, eine Verbindung herzustellen. Dies geschieht, weil in Zeile 24 eine Endlosschleife beginnt. Diese Schleife ist unendlich, da sie erst endet, wenn das Programm endet.

„Aber warte mal kurz. Die Idee, eine Endlosschleife in eine andere Schleife zu verschachteln, erscheint wenig sinnvoll. Warum sollte man das tun?“ Seien Sie versichert, liebe Leser. Die Schleife in Zeile 24 ist unendlich, aber sie endet zu einem ganz bestimmten Zeitpunkt. Da die Variable, die den Socket enthält, jedoch bereits einen Wert enthalten kann, müssen wir zunächst den alten Socket freigeben. Die Prüfung und Ausführung dieser Operation erfolgt in Zeile 26, die Freigabe in Zeile 27. Daher ist es wichtig, dass die Zeile 19 existiert. Hätten wir keine Variable deklariert, die das Nichtvorhandensein einer Verbindung anzeigt, wären wir bei der Freigabe in Zeile 27 unsicher.

Wir haben uns also auf folgendes Vorgehen geeinigt. Wenn eine Verbindung bestand, wird sie geschlossen. Falls keine Verbindung bestand, muss nicht gemacht werden. In Zeile 28 haben wir jedoch versucht, einen Socket zu erstellen. Dies wird höchstwahrscheinlich gelingen. Das Erstellen eines Sockets bedeutet jedoch nicht unbedingt, dass die Verbindung hergestellt ist. Wenn wir also in Zeile 29 keine Verbindung zum Server herstellen können, wird Zeile 32 ausgeführt. Dadurch wird eine kurze Pause eingelegt, sodass wir es erneut versuchen können.

Allerdings, und hier liegt der Kern des Problems mit der Endlosschleife in Zeile 24, wird uns ein Socket zugewiesen, wenn wir keine Verbindung zum Server herstellen können. In diesem Fall müssen wir sie an das Betriebssystem zurückgeben. Kehren wir also zu der Prüfung in Zeile 26 zurück. Diesmal wird die Prüfung jedoch erfolgreich sein, und Zeile 27 wird ausgeführt, wodurch der zugewiesene Socket freigegeben wird. Und wir wiederholen diesen Prozess des Zuweisens und Freigebens des Sockets, bis wir eine Verbindung herstellen können oder bis der Nutzer das Programm beendet.

Wenn wir uns nun die obige Animation ansehen, werden wir feststellen, dass wir irgendwann angefangen haben, Daten zu senden und zu empfangen. „Aber wenn die Schleife in Zeile 24 nie endet, wie kann das passieren?“ Der Grund liegt genau in Zeile 29. Bitte beachten Sie: Wenn es uns gelingt, eine Verbindung zum Server herzustellen, wird Zeile 30 ausgeführt, und wir verlassen die Schleife, die in Zeile 24 beginnt.

Jetzt wollen wir uns etwas sehr Interessantes ansehen. In Zeile 34 wird das Programm nur dann ausgeführt, wenn es nicht durch den Nutzer beendet wurde. Mit anderen Worten, in diesem Fall sind wir mit dem Server verbunden. Deshalb müssen wir dem Server mitteilen, wer wir sind. Die an den Server zu sendende Nachricht wird also in Zeile 36 erstellt. Beachten Sie diese Meldung. Der Server muss sie erkennen. Andernfalls trennt der Server die Verbindung zum Client, und wir kehren zur Schleife in Zeile 24 zurück. Wenn wir also in Zukunft irgendwelche Änderungen am System vornehmen wollen, müssen wir äußerst vorsichtig sein. Aber wenn alles gut geht und der Server uns als gültigen Client erkennt, dann müssen eine Reihe von Maßnahmen und bestimmte Vorsichtsmaßnahmen getroffen werden. Daher wird in Zeile 41 der Speicherpuffer gelöscht. Unmittelbar danach, in Zeile 42, geben wir die Nullposition dieses Puffers an.

Wenn Sie gerade erst anfangen, die Welt der Socket-Programmierung zu erkunden, werden Sie wahrscheinlich den Grund für die in den Zeilen 41 und 42 beschriebenen Operationen nicht verstehen. Aber wenn Sie schon etwas Erfahrung haben, wissen Sie wahrscheinlich, dass sich beim Schreiben in ein Socket viel mehr Informationen ansammeln können, als wir beim Lesen zu sehen erwarten. Genauer gesagt, geschieht dies häufig bei TCP-Verbindungen. Da wir nicht wollen, dass von Excel empfangene Anfragen oder Daten bei der Übertragung über den Server verloren gehen, müssen wir Vorkehrungen treffen, um Datenverluste zu vermeiden. Daher ist es notwendig, eine Reihe von Maßnahmen zu ergreifen. Um jedoch besser zu verstehen, wie dies zu bewerkstelligen ist und warum dies notwendig ist, müssen wir uns den Code genauer ansehen.

Dann beginnt eine neue Schleife, die Hauptschleife, d.h. die Schleife, die für den Austausch von Nachrichten zwischen Excel und MetaTrader 5 zuständig ist. Diese Schleife beginnt in Zeile 43. Sehen Sie sich nun die Schleifendeklaration an. Bitte beachten Sie, dass wir prüfen, ob das Programm beendet wurde und ob die Socket-Verbindung noch besteht. Wir gehen davon aus, dass alles in Ordnung ist, und wir können in diese Schleife eintreten und lange darin bleiben.

Als erstes müssen also einige Variablen initialisiert werden. Dies geschieht in den Zeilen 45 und 46, und unmittelbar danach beginnt eine weitere Schleife, die von Zeile 47 bis Zeile 81 reicht. Achten Sie genau darauf, was in dieser Schleife passiert. Das ist wichtig, denn hier müssen wir Änderungen oder Verbesserungen vornehmen, wenn wir etwas anderes machen wollen oder müssen, zusätzlich zu dem, was wir gezeigt und kommentiert haben. Dies wird höchstwahrscheinlich der Fall sein, wenn es notwendig wird, weitere Informationen in Excel zu übertragen. Oder auch, um die Befehle zu verstehen, die an Excel gesendet werden.

In Zeile 48 sehen wir zum Beispiel, wie viele Informationen sich in dem Socket befinden. In Zeile 51 versuchen wir dann, dieselbe Information zu lesen. Es gibt jedoch ein kleines Detail, das Sie vielleicht ändern möchten. In Zeile 49 wird geprüft, ob die Datenmenge, die in den Speicherpuffer geschrieben werden soll, die zugewiesene Puffergröße übersteigt. In diesem Fall ändern wir einfach die Menge der gelesenen Daten so, dass sie die bereits zugewiesene Größe nicht überschreitet. Falls gewünscht, können wir jedoch die Größe des zugewiesenen Bereichs ändern. In jedem Fall wird das Endergebnis sehr ähnlich sein.

Nachdem wir erklärt haben, warum Zeile 50 erscheint, können wir mit Zeile 51 fortfahren. Bitte beachten Sie, dass, wenn Daten gelesen werden, diese in Zeile 52 in den zugewiesenen Speicher eingefügt werden. In diesem Stadium der Erklärung scheint die Zeile 52 keinen Sinn zu ergeben; sie erweckt den Eindruck, dass sie überhaupt nicht existiert. Aber schauen wir uns weiter an, wie der Code funktioniert; dann wird diese Zeile verständlich. Es ist jedoch wichtig zu verstehen, dass die vom Socket gelesenen Daten ab einer bestimmten Position platziert werden. Diese Position wird durch die Variable iMem angegeben. Ich empfehle, dies nicht zu vergessen, denn beim ersten Lesen enthält die iMem-Variable einen Nullwert. Bei späteren Lesevorgängen kann er jedoch einen anderen Wert haben.

So kommen wir zu Zeile 53. Hier beginnen wir eine Schleife, die den Kern dieses Codes bildet, da sie den größten Teil der Arbeit erledigen wird. Beachten Sie, dass in diesem Prozess bestimmte Bedingungen geprüft werden; wenn diese erfüllt sind, wird auch eine Reihe kleiner Schritte ausgeführt. Diese Schritte beschreiben das Kommunikationsprotokoll zwischen MetaTrader 5 und Excel. Daher müssen alle hier vorgenommenen Änderungen auch im VBA-Code berücksichtigt werden, da VBA die Antworten von MetaTrader 5 verarbeitet. Wenn die Verarbeitung im Server-Code erfolgt, müssen entsprechende Änderungen auch im Python-Code vorgenommen werden.

Die Schleife in Zeile 53 verarbeitet die eingehende Nachricht Zeichen für Zeichen, um zu verstehen, was passiert und vor allem, wie es weitergehen soll. Wir müssen jedoch gleich klarstellen, dass dieser Code ausschließlich zu didaktischen Zwecken dient. Wenn Sie jedoch verstehen, wie alles funktioniert, können Sie denselben Code an Ihre speziellen Bedürfnisse anpassen.

Wahrscheinlich fallen Ihnen auch andere Möglichkeiten ein, das zu tun, was hier getan wird. Eine Möglichkeit ist die Verwendung der Funktion StringSplit. Damit können Sie nichts falsch machen, aber es könnte ein wenig komplizierter werden. Natürlich hängt dies alles von dem verwendeten Nachrichtenprotokoll ab. In diesem Fall ist das Protokoll recht einfach. Vor den Klammern befindet sich ein Zeichen, das berücksichtigt werden muss. Und innerhalb der Klammern wird der auszuführende Befehl angegeben. Das ist ganz einfach. Da dies jedoch nicht der Teil der Befehle ist, der für den Kauf und Verkauf auf dem Markt zuständig ist, steht Ihnen diese Funktion nicht zur Verfügung. Aber machen Sie sich darüber keine Sorgen.

Am Ende des Artikels werden wir die dafür notwendigen Links zur Verfügung stellen, da diese Funktionalität bereits im Replay-/Modellierungssystem implementiert ist. Aber wer diese Reihenfolge nicht einhält, wird nicht lernen, wie es geht. Es ist jedoch nicht schwierig. Sie müssen lediglich ein Protokoll erstellen. Um dieses Protokoll zu erstellen, müssen wir wissen, wie die angegebenen Befehle ausgeführt werden können. Wenn Sie nicht wissen, wie man das macht, sollten Sie sich die Artikel ansehen, die wir als Referenzmaterial hinterlassen werden.

Kehren wir nun zum Code zurück. Dort finden wir etwas, das viele verwirren könnte, insbesondere Anfänger. Sehen Sie sich Zeile 55 an. Zu diesem Zeitpunkt haben wir eine öffnende Klammer. Damit wird das Ende des Symbolnamens und der Beginn des Excel-Befehls angezeigt. Um das zu verdeutlichen, haben wir in Zeile 56 den Wert der Variable id, der Null war, in Eins geändert. Vergessen wir das nicht. Beim Start der Schleife war der Wert der Variable id aufgrund von Zeile 46 gleich Null; dies geschah beim ersten Durchlauf der Schleife in Zeile 43. Achten Sie auf diese Punkte.

Da die öffnende eckige Klammer anzeigt, dass der Symbolname bereits bekannt ist, müssen wir die Daten für dieses Symbol abrufen. In diesem Fall wird nur der Schlusskurs des Balkens berücksichtigt. Das ist alles, aber wir können jede Information erfassen, die wir wollen oder brauchen. Dazu reicht es aus, Regeln zu erstellen, die angeben, welcher Wert ermittelt werden soll. Aber kommen wir zurück zum eigentlichen Thema. Bitte beachten Sie, dass die case-Anweisung in Zeile 55 in die case-Anweisung in Zeile 57 übergeht, ohne dass ein break-Befehl dazwischen liegt. Ist dies möglich? Ja, das ist möglich, aber bevor Sie den Fall aus Zeile 57 erklären, sollten Sie beachten, dass es sich um ein anderes Zeichen handelt. Warum?

Jetzt kommen wir zu dem Teil, der wirklich entscheidend ist. Das Zeichen, das in Zeile 57 nach case erscheint, weist auf die Möglichkeit hin, mehrere Symbole zu trennen. Mit anderen Worten: Wenn Excel Informationen mit mehreren Symbolen suchen will, kann es dies tun, indem es sie mit diesem Zeichen trennt. Wenn wir uns jedoch den VBA-Code aus dem vorherigen Artikel ansehen, werden wir feststellen, dass diese Funktion nicht verwendet wird. Geben Sie einfach den Rückgabewert in einer einzigen Zelle aus. Das ist eine Aufgabe für Sie, liebe Leser: Teilen Sie diese Daten auf und übertragen Sie sie in die entsprechende Zelle. Da ich nicht weiß, wie jeder Programmierer seine Kalkulationstabelle erstellt, wird die Methode zur Durchführung dieser Aufteilung von Fall zu Fall unterschiedlich sein. Aber das ist nicht schwer, es hängt nur davon ab, wie Sie Ihr Arbeitsblatt erstellt haben.

In jedem Fall wird in Zeile 58 geprüft, ob das gesuchte Symbol existiert. In diesem Fall wird in Zeile 59 die Zeichenkette für die Rückgabe erstellt. Aber achten Sie auf Folgendes. Obwohl wir die zurückzugebende Zeichenkette erstellen, ist dies nicht die Zeichenkette, die wir an den Server und möglicherweise an Excel zurückgeben. Wir werden den Grund dafür später erklären. Da wir gerade das Symbol verarbeitet haben, löschen wir in Zeile 60 die Zeichenkette, um zu versuchen, das nächste Symbol zu erfassen, und in Zeile 61 verwenden wir den Break-Befehl, um zu vermeiden, dass wir zum nächsten Fall übergehen.

Im nächsten Fall, in Zeile 62, sehen wir eine schließende Klammer. Dies bedeutet, dass der von Excel erteilte Befehl erfasst wurde, und wir werden fortfahren, den Namen des nächsten Symbols zu bestimmen. Aber selbst wenn zusätzliche Informationen aus dem Socket gelesen werden, werden sie jetzt nicht verwendet. Bei der Überprüfung von Zeile 58 wird nämlich festgestellt, dass Zeile 63 angibt, dass die Daten nicht verwendet werden sollen. Teilen wir nun die Befehlssymbole auf. Aber wir müssen wissen, was jedes dieser Dinge bedeutet. Wird kein Fall ausgeführt, so wird die in Zeile 66 angegebene Standardoption ausgeführt.

Bitte beachten Sie, dass die Art der Informationen und deren Verarbeitung vom Wert der Variable id abhängt. Solange der Wert Null ist, wird also der Symbolname erfasst. Dies geschieht in Zeile 70. Wenn id eins ist, wird der von Excel bereitgestellte Befehl erfasst. Dies geschieht in Zeile 73. Wenn der Wert zwei ist, verschieben wir die Daten von der aktuellen Position an den Anfang des Speicherbereichs.

Beachten Sie, dass dadurch die Schleife, die in Zeile 47 begann, in Zeile 81 endet. Einer der Gründe dafür ist die Tatsache, dass das Ende des Befehlsblocks abgefangen wurde. Damit kommen wir zum letzten Teil der Arbeit. Doch zunächst müssen wir in Zeile 82 eine weitere Prüfung vornehmen. Wenn wir erfolgreich sind, erfolgt eine weitere Prüfung. Unser Ziel ist es, zu überprüfen, ob ein Befehl gesendet wird. Wenn ein Befehl empfangen wurde, hat dessen Verarbeitung Vorrang vor allen anderen Aktionen. An dieser Stelle, in Zeile 86, sollten die in anderen Artikeln dieser Reihe beschriebenen Maßnahmen durchgeführt werden. Auf diese Weise können wir eine Kauf- oder Verkaufsanfrage von Excel aus formulieren.

Um die Aufgabe richtig zu lösen, empfehle ich Ihnen, zunächst die ergänzenden Materialien zu studieren, die wir im Abschnitt Referenzen angeben. Als Antwort auf eine Befehlsausführungsanforderung ändert sich der Rückgabewert oder die Antwort von MetaTrader 5 und besteht nicht mehr aus den erfassten Symboldaten, sondern wird zu einer bestimmten Zeichenkette. In den Zeilen 89 und 90 wird schließlich die Antwort von MetaTrader 5 gesendet. Bitte beachten Sie, dass diese Antwort davon abhängt, ob wir einen Befehl ausführen oder Daten von einem Symbol erfassen.

Abschließende Überlegungen

Obwohl der heutige Code nicht die Implementierung der Ausführung eines von Excel gegebenen Befehls enthält, können Sie sehen, dass die Interaktion zwischen Excel und MetaTrader 5 recht reibungslos und ohne größere Probleme verläuft. Allerdings werden Sie wahrscheinlich einige kleinere Verbesserungen und Korrekturen an dieser Implementierung vornehmen müssen. Aber wenn dies geschieht, bedeutet es, dass wir unser Ziel in dieser Phase wirklich erreicht haben, in der wir erklärt haben, wie man Sockets verwendet, da viele Leute nicht wussten, dass man auf dem Markt handeln kann, ohne auf das MetaTrader 5-Chart zu schauen und ohne irgendeine fundamentale Analyse zu verwenden.

Obwohl die Implementierung des Teils, der für das Versenden von Aufträgen zuständig ist, die Implementierung anderer Elemente dieses Systems erfordert, sehe ich kein Problem darin, hier nicht zu zeigen, wie man es macht. Ich möchte, dass Sie genau wissen, was Sie tun werden. Daher werden wir die endgültige Fassung nicht zeigen. Wenn Sie jedoch die genannten Artikel studieren, werden Sie mit ziemlicher Sicherheit in der Lage sein, diese Funktion zu implementieren. Im nächsten Artikel werden wir uns mit einem anderen Thema befassen, das ebenso wie das Thema der Sockets untersucht werden muss, bevor wir zum Replay-/Modellierungssystem zurückkehren.

Referenzen:

Entwicklung eines Replay-Systems (Teil 74): Neuer Chart-Handel (I)

Entwicklung eines Replay-Systems (Teil 75): Neuer Chart-Handel (II)

Entwicklung eines Replay-Systems (Teil 76): Neuer Chart-Handel (III)

Entwicklung eines Replay-Systems (Teil 77): Neuer Chart-Handel (IV)

Entwicklung eines Replay-Systems (Teil 78): Neuer Chart-Handel (V)

Datei	Beschreibung
Experts\Expert Advisor.mq5	Demonstriert die Interaktion zwischen Chart Trade und dem Expert Advisor (erfordert Mouse Study für die Interaktion).
Indicators\Chart Trade.mq5	Erstellt ein Fenster zur Konfiguration des zu versendenden Auftrags (erfordert Mouse Study zur Interaktion).
Indicators\Market Replay.mq5	Erstellt Steuerelemente für die Interaktion mit dem Replay-/Modellierungsservice (erfordert Mouse Study für die Interaktion).
Indicators\Mouse Study.mq5	Ermöglicht die Interaktion zwischen den grafischen Steuerelementen und dem Nutzer (notwendig sowohl für das Replay-System als auch für den Echtmarkt).
Services\Market Replay.mq5	Erstellt und verwaltet den Service für das Replay bzw. der /Modellierung des Marktes (Hauptdatei des gesamten Systems).
VS C++ Server.cpp	Erstellt und verwaltet einen Socket-Server in C++ (Mini-Chat-Version).
Python Server.py	Erstellt und verwaltet einen Python-Socket für die Kommunikation zwischen MetaTrader 5 und Excel.
ScriptsCheckSocket.mq5	Ermöglicht den Test der Verbindung zu einem externen Socket
Indicators\Mini Chat.mq5	Ermöglicht die Implementierung eines Mini-Chats über einen Indikator (erfordert die Verwendung eines Servers)
Experts\Mini Chat.mq5	Ermöglicht die Implementierung eines Mini-Chats über einen Expert Advisor (erfordert die Verwendung eines Servers)