Datenaustausch zwischen Terminals via Internet mit Hilfe von WinInet.dll

--- | 15 April, 2016

Durch den Einsatz einer Reihe neuer User Interface-Elemente in seinem Arsenal, eröffnet MetaTrader 5 Anwendern, einzigartige, neue Möglichkeiten. Aus diesem Grund können bislang nicht verfügbare Funktionen jetzt optimal genutzt werden.

In diesem Beitrag lernen Sie:

  • grundlegende Internet-Technologien zu nutzen;
  • Daten zwischen Terminals via dem Server auszutauschen;
  • eine allgemeine Library-Klasse zur Arbeit mit dem Internet in der MQL5-Umgebung anzulegen.

Die MQL5 CodeBasis enthält ein Beispiel script, das mit der wininet.dll Library funktioniert und zeigt ein Beispiel der Serverseiten-Anfrage. Doch wir gehen hier viel weiter und veranlassen den Server uns nicht nur die Seite zu geben, sondern auch diese Daten zu senden und sie für weitere Übertragungen an andere anfragende Terminals zu speichern.

Hinweis: Wir empfehlen allen, die keinen Zugang zu einem PHP-konfigurierten Server haben, sich das Denwer Kit herunterzuladen, und dies als Arbeitsplattform zu verwenden Des Weiteren empfehlen wir den Apache Server und PHP bei Ihrem lokalen Host für Tests zu verwenden.

Um eine Anfrage an den Server zu senden, brauchen wir die 7 Hauptfunktionen der Library.

InternetAttemptConnect  Versucht eine Internetverbindung zu finden und diese aufzubauen
InternetOpen
Initialisiert die Struktur zur Arbeit mit den WinInet Library-Funktionen. Diese Funktion muss vor der Aktivierung aller anderen Funktionen der Library aktiviert sein.
InternetConnect Öffnet die, durch die HTTP URL oder FTP-Adresse bezeichnete, Ressource. Liefert den Deskriptor an eine offene Verbindung
HttpOpenRequest Erzeugt einen Deskriptor für HTTP-Anfragen zum Einrichten einer Verbindung
HttpSendRequest Sendet mit Hilfe des erzeugten Deskriptors eine Anfrage
InternetReadFile Liest Daten, die nach der Verarbeitung der Anfrage, vom Server empfangen werden
InternetCloseHandle Setzt den übertragenen Deskriptor frei

 
Eine Detailbeschreibung all dieser Funktionen und ihrer Parameter findet man im MSDN Hilfe-System.

Die Deklarierung der Funktionen ist dieselbe geblieben wie in MQL4, mit Ausnahme der Verwendung von Unicode-Aufrufen und Zeilentransfers durch den Link. 

#import "wininet.dll"
int InternetAttemptConnect(int x);
int InternetOpenW(string &sAgent,int lAccessType,string &sProxyName,string &sProxyBypass,int lFlags);
int InternetConnectW(int hInternet,string &szServerName,int nServerPort,string &lpszUsername,string &lpszPassword,int dwService,int dwFlags,int dwContext);
int HttpOpenRequestW(int hConnect,string &Verb,string &ObjectName,string &Version,string &Referer,string &AcceptTypes,uint dwFlags,int dwContext);
int HttpSendRequestW(int hRequest,string &lpszHeaders,int dwHeadersLength,uchar &lpOptional[],int dwOptionalLength);
int HttpQueryInfoW(int hRequest,int dwInfoLevel,int &lpvBuffer[],int &lpdwBufferLength,int &lpdwIndex);
int InternetReadFile(int hFile,uchar &sBuffer[],int lNumBytesToRead,int &lNumberOfBytesRead);
int InternetCloseHandle(int hInet);
#import

//To make it clear, we will use the constant names from wininet.h.
#define OPEN_TYPE_PRECONFIG     0           // use the configuration by default
#define FLAG_KEEP_CONNECTION    0x00400000  // do not terminate the connection
#define FLAG_PRAGMA_NOCACHE     0x00000100  // no cashing of the page
#define FLAG_RELOAD             0x80000000  // receive the page from the server when accessing it
#define SERVICE_HTTP            3           // the required protocol

Eine Detailbeschreibung aller 'Flaggen' für jede der Funktionen findet sich im ebwefalls im MSDN-Bereich. Wenn Sie die Deklarierung anderer Konstanten und Funktionen sehen möchten, laden Sie sich einfach die ursprüngliche wininet.h-Datei herunter, die sich im Anhang an diesen Beitrag befindet.

1. Anleitungen zum Erzeugen und Löschen einer Internet-Sitzung

Als erstes müssen wir eine Sitzung erzeugen und eine Verbddnung zum Host öffnen. Es ist ratsam während der Programminitialisierung eine Sitzung nur einmal zu erzeugen (z.B. in einer OnInit Funktion), oder man tut dies ganz zu Anfang beim Starten des Expert Advisors. Wichtig jedoch ist, sicherzugehen, dass eine Sitzung nur einmal erfolgreich erzeugt wurde, bevor man sie wieder schließt. Und sie sollte bei jeder neuen Wiederholung der Implementierung von OnStart oder OnTimer weder immer wieder noch unnötig aufgerufen werden. Wichtig hierbei ist, häufige Aufrufe und die Erzeugung der für jeden Aufruf nötigen Strukturen zu vermeiden.

Daher verwenden wir zur Beschreibung der Sitzung und Verbindungs-Deskriptoren nur eine globale Klasseninstanz.

   string            Host;       // host name
   int               Port;       // port
   int               Session;    // session descriptor
   int               Connect;    // connection descriptor

bool MqlNet::Open(string aHost,int aPort)
  {
   if(aHost=="")
     {
      Print("-Host is not specified");
      return(false);
     }
   // checking the DLL resolution in the terminal  
   if(!TerminalInfoInteger(TERMINAL_DLLS_ALLOWED))
     {
      Print("-DLL is not allowed");
      return(false);
     }
   // if the session was identifies, then we close
   if(Session>0 || Connect>0) Close();
   // record of attempting to open into the journal
   Print("+Open Inet...");
   // if we were not able to check for the presence of an Internet connection, then we exit
   if(InternetAttemptConnect(0)!=0)
     {
      Print("-Err AttemptConnect");
      return(false);
     }
   string UserAgent="Mozilla"; string nill="";
   // open a session
   Session=InternetOpenW(UserAgent,OPEN_TYPE_PRECONFIG,nill,nill,0);
   // if we were not able to open a session, then exit
   if(Session<=0)
     {
      Print("-Err create Session");
      Close();
      return(false);
     }
   Connect=InternetConnectW(Session,aHost,aPort,nill,nill,SERVICE_HTTP,0,0);
   if(Connect<=0)
     {
      Print("-Err create Connect");
      Close();
      return(false);
     }
   Host=aHost; Port=aPort;
   // otherwise all attempts were successful
   return(true);
  }

Nach der Initialisierung können die Deskriptoren Sitzung und Verbindung in allen der folgenden Funktionen verwendet werden. Ist die komplette Arbeit abgeschlossen und die MQL-Programme deinstalliert, müssen sie auch entfernt werden. Dies geschieht mit Hilfe der InternetCloseHandle Funktion.

void MqlNet::CloseInet()
  {
   Print("-Close Inet...");
   if(Session>0) InternetCloseHandle(Session); Session=-1;
   if(Connect>0) InternetCloseHandle(Connect); Connect=-1;
  }

Achtung! Bei der Arbeit mit Internetfunktionen ist es wichtig, alle von ihnen abgeleiteten Deskriptoren freizumachen, und zwar mittels InternetCloseHandle.

2. Eine Anfrage an den Server senden und die Seite empfangen

Zum Senden einer Anfrage und dem Empfangen einer Seite als Antwort auf diese Anfrage, brauchen wir die drei restlichen Funktionen HttpOpenRequest, HttpSendRequest und InternetReadFile. Der Kern des Empfangens einer Seite als Antwort auf eine Anfrage, ist im Grunde der einfache Vorgang des Abspeicherns ihres Inhalts in eine lokale Datei.


Für bequemes Arbeiten mit Anfragen und Inhalten, erzeugen wir zwei universelle Funktionen

Eine Anfrage senden:

bool MqlNet::Request(string Verb,string Object,string &Out,bool toFile=false,string addData="",bool fromFile=false)
  {
   if(toFile && Out=="")
     {
      Print("-File is not specified ");
      return(false);
     }
   uchar data[];
   int hRequest,hSend,h;
   string Vers="HTTP/1.1";
   string nill="";
   if(fromFile)
     {
      if(FileToArray(addData,data)<0)
        {
         Print("-Err reading file "+addData);

         return(false);
        }
     } // read file in the array
   else StringToCharArray(addData,data);

   if(Session<=0 || Connect<=0)
     {
      Close();
      if(!Open(Host,Port))
        {
         Print("-Err Connect");
         Close();
         return(false);
        }
     }
   // create a request descriptor
   hRequest=HttpOpenRequestW(Connect,Verb,Object,Vers,nill,nill,FLAG_KEEP_CONNECTION|FLAG_RELOAD|FLAG_PRAGMA_NOCACHE,0);
   if(hRequest<=0)
     {
      Print("-Err OpenRequest");
      InternetCloseHandle(Connect);
      return(false);
     }
   // send request
   // headline for request
   string head="Content-Type: application/x-www-form-urlencoded";
   // sent file
   hSend=HttpSendRequestW(hRequest,head,StringLen(head),data,ArraySize(data)-1);
   if(hSend<=0)
     {
      Print("-Err SendRequest");
      InternetCloseHandle(hRequest);
      Close();
     }
   // read the page 
   ReadPage(hRequest,Out,toFile);
   // close all handles
   InternetCloseHandle(hRequest); 
   InternetCloseHandle(hSend);
   return(true);
  }

Funktionsparameter von MqlNet:: Anfrage:

  • string Verb – Anfrageart “HOLEN” oder “POSTEN”;
  • string Object – Name der Seite mit ihren übertragenen Parametern;
  • string &Out – Zeile, in der die Antwort empfangen wird;
  • bool toFile – wenn toFile=true, gibt 'Out' den Namen der Datei an, in der die Antwort empfangen werden sollte;
  • string addData - weitere Daten;
  • bool fromFile - wenn fromFile = true, bezeichnet 'addData' den Namen der Datei, die gesendet werden muss

Die Inhalte des empfangenen Deskriptors lesen

void MqlNet::ReadPage(int hRequest,string &Out,bool toFile)
  {
   // read the page 
   uchar ch[100];
   string toStr="";
   int dwBytes,h;
   while(InternetReadFile(hRequest,ch,100,dwBytes))
     {
      if(dwBytes<=0) break;
      toStr=toStr+CharArrayToString(ch,0,dwBytes);
     }
   if(toFile)
     {
      h=FileOpen(Out,FILE_BIN|FILE_WRITE);
      FileWriteString(h,toStr);
      FileClose(h);
     }
   else Out=toStr;
  }

Funktionsparameter von MqlNet:: Seitelesen:

  • Int hRequest - Anfrage-Deskriptor, aus dem die Daten gelesen werden;
  • string &Out – Zeile, in der die Antwort empfangen wird;
  • bool toFile - wenn toFile = true, gibt 'Out' den Namen der Datei an, in der die Antwort empfangen werden sollte.

Und wenn wir all dies in eine Einheit vereinen, erhalten wir eine MqlNet Library-Klasse zur Arbeit mit dem Internet.

class MqlNet
  {
   string            Host;     // host name
   int               Port;     // port
   int               Session; // session descriptor
   int               Connect; // connection descriptor
public:
                     MqlNet(); // class constructor
                    ~MqlNet(); // destructor
   bool              Open(string aHost,int aPort); // create a session and open a connection
   void              Close(); // close session and connection
   bool              Request(string Verb,string Request,string &Out,bool toFile=false,string addData="",bool fromFile=false); // send request
   bool              OpenURL(string URL,string &Out,bool toFile); // somply read the page into the file or the variable
   void              ReadPage(int hRequest,string &Out,bool toFile); // read the page
   int               FileToArray(string FileName,uchar &data[]); // copy the file into the array for sending
  };

Und das sind im Grunde alle erforderlichen Funktionen, mit denen fast alle unterschiedlichen Bedürfnisse bei der Arbeit mit dem Internet erfüllt werden können. Sehen wir uns die Anwendungsbeispiele an.

Beispiel 1 Automatischer Download von MQL-Programmen in die Ordner des Terminals MetaGrabber Script

Zu Beginn unseres Tests der Arbeit der Klassen, probieren wir zunächst die leichteste Aufgabe aus - das Lesen der Seite und Speichern ihres Inhalts in einen spezifizierten Ordner. Doch das einfache Lesen der Seiten ist sicherlich nicht besonders interessant, sodass wir, damit wir von der Arbeit des Scripts auch etwas haben, ihm einen funktionalen Grabber von mql-Programmen von Websites zuweisen. Das MetaGrabber Script soll folgendes ausführen:

  • URL-Analyse und Aufteilung der URL in Host, die Anfrage und den Dateinamen;
  • eine Anfrage an den Host senden, die Datei empfangen und sie im Terminal-Ordner \\ Dateien speichern;
  • die Datei von den Dateien in einen der erforderlichen Datenordner verschieben:
    \Experts, \Indikatoren, \Scripts, \Einschließen, \Libraries, \Tester(set), \Templates.

Um das zweite Problem zu lösen, verwenden wir die MqlNet Klasse. Für die dritte Aufgabe nehmen wir MoveFileEx aus Kernel32.dll her

#import "Kernel32.dll"
bool MoveFileExW(string &lpExistingFileName, string &lpNewFileName, int dwFlags);
#import "Kernel32.dll"

Für das erste Problem erstellen wir schnell eine kleine Dienstfunktion zur Zerteilung der URL-Zeile.

Wir müssen aus der Adresse drei separate Zeilen zuweisen: den Host, den Pfad zur Website und den Dateinamen.
Beispiel: in der Zeile http://www.mysite.com/folder/page.html ist der

Host = www.mysite.com
- die Anfrage = / folder / page.html
und der Dateiname = page.html

In Falle der CodeBasis auf der MQL5 Website haben die Pfadwege die gleiche Struktur. So sieht z.B. der Pfad zur Library ErrorDescription.mq5 auf der Website https://www.mql5.com/ru/code/79 aus wie http://p.mql5.com/data/18/79/ErrorDescription.mqh. Diesen Pfad erhält man ganz leicht durch Rechtsklick auf den Link und Auswahl von "Link kopieren". Somit wird die URL in zwei Teile unterteilt - einen für die Anfrage und einen für den Dateinamen für bequemes Speichern der Datei.

- Host = p.mql5.com
- Anfrage = / data/18/79/5/ErrorDescription.mqh
- Dateiname = ErrorDescription.mqh

Das ist die Art von Zeilenaufteilung, mit der sich die folgende ParseURL Funktion beschäftigen wird.

void ParseURL(string path,string &host,string &request,string &filename)
  {
   host=StringSubstr(URL,7);
   // removed
   int i=StringFind(host,"/"); 
   request=StringSubstr(host,i);
   host=StringSubstr(host,0,i);
   string file="";
   for(i=StringLen(URL)-1; i>=0; i--)
      if(StringSubstr(URL,i,1)=="/")
        {
         file=StringSubstr(URL,i+1);
         break;
        }
   if(file!="") filename=file;
  }

In den äußeren Parametern des Scripts machen wir nur zwei Parameter - URL (Pfad der mql5 Datei) und die des Ordners für die nachfolgende Ablage - also in welchen Terminalordner sie abgelegt werden soll.

Als Ergebnis erhalten wir ein kurzes, aber sehr nützliches Script.

//+------------------------------------------------------------------+
//|                                                  MetaGrabber.mq5 |
//|                                 Copyright © 2010 www.fxmaster.de |
//|                                         Coding by Sergeev Alexey |
//+------------------------------------------------------------------+
#property copyright "www.fxmaster.de  © 2010"
#property link      "www.fxmaster.de"
#property version               "1.00"
#property description  "Download files from internet"

#property script_show_inputs

#include <InternetLib.mqh>

#import "Kernel32.dll"
bool MoveFileExW(string &lpExistingFileName,string &lpNewFileName,int dwFlags);
#import
#define MOVEFILE_REPLACE_EXISTING 0x1

enum _FolderType
  {
   Experts=0,
   Indicators=1,
   Scripts=2,
   Include=3,
   Libraries=4,
   Files=5,
   Templates=6,
   TesterSet=7
  };

input string URL="";
input _FolderType FolderType=0;
//------------------------------------------------------------------ OnStart
int OnStart()
  {
   MqlNet INet; // variable for working in the Internet
   string Host,Request,FileName="Recieve_"+TimeToString(TimeCurrent())+".mq5";

   // parse url
   ParseURL(URL,Host,Request,FileName);

   // open session
   if(!INet.Open(Host,80)) return(0);
   Print("+Copy "+FileName+" from  http://"+Host+" to "+GetFolder(FolderType));

   // obtained file
   if(!INet.Request("GET",Request,FileName,true))
     {
      Print("-Err download "+URL);
      return(0);
     }
   Print("+Ok download "+FileName);

   // move to the target folder
   string to,from,dir;
   // if there is no need to move it elsewhere
   if(FolderType==Files) return(0);

   // from
   from=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Files\\"+FileName;

   // to
   to=TerminalInfoString(TERMINAL_DATA_PATH)+"\\";
   if(FolderType!=Templates && FolderType!=TesterSet) to+="MQL5\\";
   to+=GetFolder(FolderType)+"\\"+FileName;

   // move file 
   if(!MoveFileExW(from,to,MOVEFILE_REPLACE_EXISTING))
     {
      Print("-Err move to "+to);
      return(0);
     }
   Print("+Ok move "+FileName+" to "+GetFolder(FolderType));

   return(0);
  }
//------------------------------------------------------------------ GetFolder
string GetFolder(_FolderType foldertype)
  {
   if(foldertype==Experts) return("Experts");
   if(foldertype==Indicators) return("Indicators");
   if(foldertype==Scripts) return("Scripts");
   if(foldertype==Include) return("Include");
   if(foldertype==Libraries) return("Libraries");
   if(foldertype==Files) return("Files");
   if(foldertype==Templates) return("Profiles\\Templates");
   if(foldertype==TesterSet) return("Tester");
   return("");
  }
//------------------------------------------------------------------ ParseURL
void ParseURL(string path,string &host,string &request,string &filename)
  {
   host=StringSubstr(URL,7);
   // removed
   int i=StringFind(host,"/"); 
   request=StringSubstr(host,i);
   host=StringSubstr(host,0,i);
   string file="";
   for(i=StringLen(URL)-1; i>=0; i--)
      if(StringSubstr(URL,i,1)=="/")
        {
         file=StringSubstr(URL,i+1);
         break;
        }
   if(file!="") filename=file;
  }
//+------------------------------------------------------------------+


Führen wir die Versuche an unserem Lieblingsabschnitt https://www.mql5.com/de/code aus. Die heruntergeladenen Dateien erscheinen sofort im Navigator des Editors und können ohne Neustart des Terminals oder Editors kompiliert werden. Und sie durchlaufen zudem auch nicht die langen Pfade des Dateisystems auf der Suche nach dem gewünschten Ordner, in den die Dateien verschoben werden sollen.

Achtung! Viele Websites haben ein Sicherheitssystem zur Verhinderung massiven Downloads von Inhalten eingerichtet, sodass bei einem solchen Massen-Download u.U. Ihre IP-Adresse von dieser Ressource blockiert werden kann. Seien Sie also vorsichtig beim "Maschinen"-Download von Dateien bei Ressourcen, auf die Sie oft zugreifen und von deren weiteren Zugriff Sie nicht ausgesperrt werden wollen.

Alle diejenigen, die sogar noch weiter gehen möchten und den vorgeschlagenen Dienst verbessern möchten, können das Clipboard-Script verwenden, mit dem Abfangen der Inhalte des Clipboards und dem weiteren automatischen Download.

Beispiel 2 Kontrolle der Notierungen mehrerer Makler auf einem einzigen Chart

Wir können also inzwischen Dateien aus dem Internet erhalten. Wenden wir uns daher nun einer weit interessanteren Frage zu - wie werden diesen Daten an den Server gesendet und dort auch gespeichert? Dazu brauchen wir ein weiteres, kleines PHP-Script, das sich auf dem Server befinden wird. Mit Hilfe der geschriebenen MqlNet-Klasse erzeugen wir einen Expert Advisor für Kontrolle - MetaArbitrage . Die Aufgabe des Expert, in Verbindung mit dem PHP-Script ist folgende:

  • Senden einer Expert Advisor-Anfrage an den Server;
  • Aufbau der Antwortseite (PHP) auf dem Server;
  • Empfang dieser Seite durch den Expert Advisor,
  • sowie ihre Analyse und die Anzeige der Ergebnisse auf dem Bildschirm.

Das schematische Diagramm der Interaktion zwischen dem MQL-Modul und dem PHP-Script sieht wir folgt aus:


Um diese Aufgaben zu lösen, verwenden wir die MqlNet Klasse.

Zur Vermeidung von Datenduplikation und auch, um veraltete Quoten zu entfernen, verwenden wir 4 Hauptparameter: den Namen des Servers des Maklers (Quelle der aktuellen Preise), die Währung sowie den Preis und die Uhrzeit der Quoten in UTC. So sieht z.B. eine Anfrage für den Zugriff auf das Script von den Ressourcen unserer Firma folgendermaßen aus:

www.fxmaster.de/metaarbitr.php?server=Metaquotes&pair=EURUSD&bid=1.4512&time=13286794

Diese Parameter und die aktuelle Quote werden auf dem Server abgelegt und, zusammen mit allen gespeicherten Quoten dieser Währung, auf der Antwortseite ausgegeben.

Der "zusätzliche" Nutzen dieses Austauschs besteht darin, dass Quoten sowohl von MT5 als auch von MT4 gesendet werden können!

Die Seite, die vom Server erstellt wird, ist eine normale csv-Datei. In diesem Script sieht sie so aus:

ServerName1; Geldkurs1; Uhrzeit1
ServerName 2; Geldkurs2; Uhrzeit2
ServerName 3; Geldkurs3; Uhrzeit3
…
ServerName N; GeldkursN; UhrzeitN

Sie können sie jedoch mit Ihren eingenen zusätzlichen Parametern ergänzen (z.B. Servertyp - Demo oder echt). Diese csv-Datei legen wir ab und zerteilen sie Zeile für Zeile, wobei das Ergebnis in einer Tabelle aus Wert und Zeilenpreisen auf dem Bildschirm angezeigt wird.

Mann kann diese Datei auf viele verschiedene Arten verarbeiten, sodass man sich genau die aussuchen kann, die in jedem einzelnen Fall auch erforderlich sind. So kann man z.B. die Quoten, die man vom MetaTrader 4 Demo-Server erhalten hat, herausfiltern, usw.


Die Vorteile in der Nutzung des Internetservers sind klar - Sie senden Ihre Quoten, die dann von jedem anderen Händler empfangen und betrachtet werden können. Und genauso erhalten auch Sie Quoten, die an andere Händler gesendet wurden. Das heißt: die Interaktion zwischen den Terminals ist zweiseitig, und der Datenaustausch wird, wie im folgenden Schema dargestellt, bewerkstelligt:


Dieses Schema dient als die Basis für das Prinzip des Informationsaustausches zwischen jeder beliebigen Anzahl von Terminals. Ein kompletter MetaArbitrage Expert Advisor samt seinem PHP-Script mit Anmerkungen können mit Hilfe des Links im Anhang an diesen Beitrag heruntergeladen werden. Mehr Einzelheiten über Funktionen, die PHP benutzen, können auf folgender Website nachgelesen werden: php.su

Beispiel 3 Austausch von Nachrichten (Mini-Chat) innerhalb des Terminals. MetaChat Expert Advisor

Gehen wir jetzt einen Schritt weg von Handel und Zahlen und erzeugen eine Anwendung, mit der wir mit mehreren Personen gleichzeitig chatten können, ohne das Terminal verlassen zu müssen. Dazu brauchen wir ein weiteres PHP-Script, das dem vorigen generell sehr ähnelt. Einziger Unterschied: In diesem Script analysieren wir, anstelle von Zeitnotierungen, die Anzahl der Zeilen in einer Datei. Die Aufgabe des Expert Advisors ist dabei folgende:

  • Eine Textzeile an den Server senden;
  • Ergänzung der geteilten Datei mit dieser Zeile, Kontrolle der Dateigröße und Ausgabe der Antwortdatei (php);
  • Empfang des aktuellen Chats und seine Anzeige auf dem Bildschirm.

Die Arbeit von MetaChat unterscheidet sich in keiner Weise von der des vorigen Expert Advisors. Das gleiche Arbeitsprinzip und die gleiche csv-Ausgabedatei.


MetaChat und MetaArbitrage werden auf der Website ihrer Entwickler gepflegt. Dort finden sich auch die PHP-Scripts für ihre Arbeit.
Wenn Sie also eine Arbeit testen oder diesen Service nutzen wollen, haben Sie darauf Zugriff mittels folgendem Link:
MetaСhat - www.fxmaster.de/metachat.php
MetaArbitrage - www.fxmaster.de/metaarbitr.php

Fazit

Wir haben uns also jetzt mit HTTP-Anfragen vertraut gemacht. Wir haben die Fähigkeit erworben, Daten mittels Internet zu senden und zu empfangen und unseren Arbeitsvorgang bequemer zu gestalten. Doch jede Fähigkeit kann noch weiter verbessert werden. Die folgenden Punkte können daher als potenzielle Richtungen für entsprechende Verbesserungen betrachtet werden:

  • Neuigkeiten oder andere Informationen direkt im Terminal lesen oder erhalten, zur Analyse von Expert Advisors;
  • Remote-Verwaltung von Expert Advisors;
  • Automatische Aktualisierungen von Expert Advisors / Indikatoren;
  • Kopier- / Übersetzungsfunktionen von Handel, Signale senden;
  • Download von Templates zusammen mit Lichtern und SetFiles für Expert Advisors:
  • Und noch viel mehr...

In diesem Beitrag haben wir mit dem Anfragetyp HOLEN gearbeitet. Diese Anfragen kümmern sich, mit nur wenigen Parametern, um die Aufgaben, wenn man für Serveranalysen eine Datei benötigt oder eine Anfrage senden möchte.

Im nächsten Beitrag sehen wir uns den Anfragetyp POSTEN genauer an - das Senden von Dateien an den Server oder das Teilen von Dateien zwischen Terminals und betrachten auch entsprechende Anwendungsbeispiele.

Nützliche Ressourcen