MetaTrader 5 herunterladen

Unterstützen Sie Ihre Entwicklungsprojekte mit EX5-Bibliotheken

29 April 2016, 15:36
o_o
0
189

Einleitung

Der erfahrene Leser braucht keine Erklärung des Zwecks hinter dem Verbergen von Funktionen und Klassenimplementierungen in Bibliotheken. Jene von Ihnen, die aktiv nach neuen Ideen suchen, sollten wissen, dass Sie durch das Verbergen der Umsetzungsdetails von Klassen/Funktionen in einer .ex5-Datei Ihre Algorithmen mit anderen Entwicklern teilen, gemeinsame Projekte in die Wege leiten und sie im Internet bewerben können.

Und während das Team von MetaQuotes keine Mühen scheut, um die direkte Vererbung von ex5-Bibliotheksklassen zu ermöglichen, setzen wir sie jetzt schon um.

Inhaltsverzeichnis

1. Export und Import von Funktionen
2. Export der verborgenen Umsetzung einer Klasse
3. Initialisierung von Variablen in .ex5-Dateien
4. Vererbung von Export-Klassen
5. Veröffentlichen von ex5-Bibliotheken


1. Export und Import von Funktionen

Dies ist eine Grundlegende Methode hinter dem Export von Klassen. Drei wichtige Faktoren müssen berücksichtigt werden, damit andere Programme auf Ihre Funktionen zugreifen können:

  1. Die zu erstellende Datei muss die Erweiterung .mq5 (nicht .mqh) haben, damit sie zu einer .ex5-Datei kompiliert werden kann;
  2. Die Datei muss die Präprozessor-Direktive #property library enthalten;
  3. Hinter die Kopfzeilen der erforderlichen zu exportierenden Dateien muss das Schlüsselwort "export" gestellt werden
Example 1. Let us create a function to be used in other programs

//--- library.mq5
#property library
int libfunc (int a, int b) export
{
  int c=a+b;
  Print("a+b="+string(с));
  return(с);
}

Nach dem Kompilieren dieser Datei erhalten Sie die Datei library.ex5, aus der die Funktion libfunc in anderen Programmen verwendet werden kann.

Der Prozess für den Import von Funktionen ist ebenfalls sehr einfach. Er wird mithilfe der Präprozessor-Direktive #import durchgeführt.

Example 2. We will use the export function libfunc() in our script

//--- uses.mq5
#import "library.ex5"
  int libfunc(int a, int b);
#import

void OnStart()
{
  libfunc(1, 2);
}

Denken Sie daran, dass der Compiler nach .ex5-Dateien im Ordner MQL5\Libraries suchen wird. Wenn sich library.ex5 also nicht in diesem Ordner befindet, müssen Sie den relativen Pfad angeben.

Z. B.:

#import "..\Include\MyLib\library.ex5" // the file is located in the MQL5\Include\MyLib folder
#import "..\Experts\library.ex5" // the file is located in the MQL5\Experts\ folder

Für Ihre zukünftige Verwendung können Funktionen nicht nur in die Ziel-.mq5-Datei, sondern auch in .mqh-Dateien importiert werden.

Nutzen wir ein paar Grafiken, um die praktische Anwendung zu illustrieren.

Wir erstellen eine Bibliothek von Funktionen für den Export. Diese Funktionen werden grafische Objekte wie Button, Edit, Label und Rectangle Label in einem Diagramm anzeigen, die Objekte aus dem Diagramm löschen und die Farbparameter des Diagramms zurücksetzen.

Schematisch lässt sich dies wie folgt darstellen:

Exportschema von Klassenmethoden

Die vollständige Datei Graph.mq5 finden Sie am Ende des Beitrags. Hier führen wir nur ein Vorlagebeispiel der Zeichenfunktion Edit auf.

//+------------------------------------------------------------------+
//| SetEdit                                                          |
//+------------------------------------------------------------------+
void SetEdit(long achart,string name,int wnd,string text,color txtclr,color bgclr,color brdclr,
             int x,int y,int dx,int dy,int corn=0,int fontsize=8,string font="Tahoma",bool ro=false) export
  {
   ObjectCreate(achart,name,OBJ_EDIT,wnd,0,0);
   ObjectSetInteger(achart,name,OBJPROP_CORNER,corn);
   ObjectSetString(achart,name,OBJPROP_TEXT,text);
   ObjectSetInteger(achart,name,OBJPROP_COLOR,txtclr);
   ObjectSetInteger(achart,name,OBJPROP_BGCOLOR,bgclr);
   ObjectSetInteger(achart,name,OBJPROP_BORDER_COLOR,brdclr);
   ObjectSetInteger(achart,name,OBJPROP_FONTSIZE,fontsize);
   ObjectSetString(achart,name,OBJPROP_FONT,font);
   ObjectSetInteger(achart,name,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(achart,name,OBJPROP_YDISTANCE,y);
   ObjectSetInteger(achart,name,OBJPROP_XSIZE,dx);
   ObjectSetInteger(achart,name,OBJPROP_YSIZE,dy);
   ObjectSetInteger(achart,name,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(achart,name,OBJPROP_READONLY,ro);
   ObjectSetInteger(achart,name,OBJPROP_BORDER_TYPE,0);
   ObjectSetString(achart,name,OBJPROP_TOOLTIP,"");
  }

Der Import der erforderlichen Funktionen und deren Verwendung werden in der Zieldatei Spiro.mq5 umgesetzt:

Example 3. Using imported functions

//--- Spiro.mq5 – the target file of the Expert Advisor

//--- importing some graphics functions
#import "Graph.ex5" 
  void SetLabel(long achart, string name, int wnd, string text, color clr, 
               int x, int y, int corn=0, int fontsize=8, string font="Tahoma");
  void SetEdit(long achart, string name, int wnd, string text, color txtclr, color bgclr, color brdclr, 
                 int x, int y, int dx, int dy, int corn=0, int fontsize=8, string font="Tahoma", bool ro=false);
  void SetButton(long achart, string name, int wnd, string text, color txtclr, color bgclr, 
                int x, int y, int dx, int dy, int corn=0, int fontsize=8, string font="Tahoma", bool state=false);
  void HideChart(long achart, color BackClr);
#import

//--- prefix for chart objects
string sID; 
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

void OnInit()
{
  HideChart(0, clrWhite);
  sID="spiro.";
  DrawParam();
}
//+------------------------------------------------------------------+
//| DrawParam                                                        |
//+------------------------------------------------------------------+
void DrawParam()
{
  color bgclr=clrWhite, clr=clrBlack;
//--- bigger radius    
  SetLabel(0, sID+"stR.", 0, "R", clr, 10, 10+3);
  SetEdit(0, sID+"R.", 0, "100", clr, bgclr, clr, 40, 10, 50, 20);
//--- smaller radius   
  SetLabel(0, sID+"str.", 0, "r", clr, 10, 35+3);
  SetEdit(0, sID+"r.", 0, "30", clr, bgclr, clr, 40, 35, 50, 20);
//--- distance to the center
  SetLabel(0, sID+"stD.", 0, "D", clr, 10, 60+3);
  SetEdit(0, sID+"D.", 0, "40", clr, bgclr, clr, 40, 60, 50, 20);
//--- drawing accuracy
  SetLabel(0, sID+"stA.", 0, "Alfa", clr, 10, 85+3); 
  SetEdit(0, sID+"A.", 0, "0.04", clr, bgclr, clr, 40, 85, 50, 20);
//--- drawing accuracy
  SetLabel(0, sID+"stN.", 0, "Rotor", clr, 10, 110+3); 
  SetEdit(0, sID+"N.", 0, "10", clr, bgclr, clr, 40, 110, 50, 20);
//--- draw button
  SetButton(0, sID+"draw.", 0, "DRAW", bgclr, clr, 39, 135, 51, 20); 
}

Nach der Ausführung des Expert Advisor erscheinen die Objekte im Diagramm:

Beispiel für die Verwendung von Bibliotheksobjekten

Wie Sie sehen können, ist der Prozess für den Export und Import von Funktionen überhaupt nicht schwierig, aber lesen Sie dennoch die Informationen über bestimmte Einschränkungen in der Hilfe: export, import.


2. Export der verborgenen Umsetzung einer Klasse

Da Klassen in MQL5 aktuell nicht direkt exportiert werden können, müssen wir auf eine recht anspruchsvolle Methode zurückgreifen. Sie basiert auf Polymorphie und virtuellen Funktionen. Tatsächlich wird nicht die Klasse selbst aus dem ex5-Modul ausgegeben, sondern ein erstelltes Objekt von ihr. Nennen wir es das Objekt der verborgenen Umsetzung.

Der Sinn dieser Methode ist es, die erforderliche Klasse in zwei Klassen aufzuteilen, sodass die Deklarierung von Funktionen und Variablen öffentlich zugänglich ist und ihre Umsetzungsdetails in einer geschlossenen .ex5-Datei verborgen sind.

Dies lässt sich folgendermaßen veranschaulichen. Wir haben die Klasse CSpiro, die wir mit anderen Entwicklern teilen möchten, ohne ihre Umsetzungsdetails offenzulegen. Nehmen wir an, sie enthält Variablen, einen Konstruktor, einen Destruktor und Arbeitsfunktionen.

Um die Klasse zu exportieren, müssen wir Folgendes tun:

  • Einen Klon des Nachfahren der Klasse CSpiro erstellen. Nennen wir ihn ISpiro (das C wird durch ein I ersetzt, abgeleitet vom Wort "interface").
  • Alle Variablen und Dummy-Funktionen in der ursprünglichen Klasse CSpiro belassen.
  • Die Umsetzungsdetails der Funktionen formen die neue Klasse ISpiro.
  • Diese Klasse zur Exportfunktion hinzufügen, die eine Instanz der geschlossenen Klasse ISpiro erstellt.
  • Hinweis! Alle erforderlichen Funktionen müssen das Präfix virtual haben.

Als Ergebnis erhalten wir zwei Dateien:

Example 4. Hiding of the class implementation in the ex5 module

//--- Spiro.mqh – public file, the so called header file

//+------------------------------------------------------------------+
//| Class CSpiro                                                     |
//| Spirograph draw class                                       |
//+------------------------------------------------------------------+
class CSpiro
  {
public:
   //--- prefix of the chart objects
   string            m_sID;
   //--- offset of the chart center
   int               m_x0,m_y0;
   //--- color of the line
   color             m_clr;
   //--- chart parameters
   double            m_R,m_r,m_D,m_dAlfa,m_nRotate;

public:
   //--- constructor
                     CSpiro() { };
   //--- destructor
                    ~CSpiro() { };
   virtual void Init(int ax0,int ay0,color aclr,string asID) { };
   virtual void SetData(double aR,double ar,double aD,double adAlpha,double anRotate) { };

public:
   virtual void DrawSpiro() { };
   virtual void SetPoint(int x,int y) { };
  };

Beachten Sie, dass alle Funktionen der Klasse mit dem Schlüsselwort virtual deklariert werden.

//--- ISpiro.mq5 – hidden implementation file

#include "Spiro.mqh"

//--- importing some functions
#import "..\Experts\Spiro\Graph.ex5"
void SetPoint(long achart,string name,int awnd,int ax,int ay,color aclr);
void ObjectsDeleteAll2(long achart=0,int wnd=-1,int type=-1,string pref="",string excl="");
#import

CSpiro *iSpiro() export { return(new ISpiro); }
//+------------------------------------------------------------------+
//| Сlass ISpiro                                                     |
//| Spirograph draw class                                       |
//+------------------------------------------------------------------+
class ISpiro : public CSpiro
  {
public:
                     ISpiro() { m_x0=0; m_y0=0; };
                    ~ISpiro() { ObjectsDeleteAll(0,0,-1); };
   virtual void      Init(int ax0,int ay0,color aclr,string asID);
   virtual void      SetData(double aR,double ar,double aD,double adAlpha,double anRotate);

public:
   virtual void      DrawSpiro();
   virtual void      SetPoint(int x,int y);
  };
//+------------------------------------------------------------------+
//| Init                                                             |
//+------------------------------------------------------------------+
void ISpiro::Init(int ax0,int ay0,color aclr,string asID)
  {
   m_x0=ax0;
   m_y0=ay0;
   m_clr=aclr;
   m_sID=asID;
   m_R=0; 
   m_r=0; 
   m_D=0;
  }
//+------------------------------------------------------------------+
//| SetData                                                          |
//+------------------------------------------------------------------+
void ISpiro::SetData(double aR,double ar,double aD,double adAlpha,double anRotate)
  {
   m_R=aR; m_r=ar; m_D=aD; m_dAlfa=adAlpha; m_nRotate=anRotate;
  }
//+------------------------------------------------------------------+
//| DrawSpiro                                                        |
//+------------------------------------------------------------------+
void ISpiro::DrawSpiro()
  {
   if(m_r<=0) { Print("Error! r==0"); return; }
   if(m_D<=0) { Print("Error! D==0"); return; }
   if(m_dAlfa==0) { Print("Error! Alpha==0"); return; }
   ObjectsDeleteAll2(0,0,-1,m_sID+"pnt.");
   int n=0; double a=0;
   while(a<m_nRotate*2*3.1415926)
     {
      double x=(m_R-m_r)*MathCos(a)+m_D*MathCos((m_R-m_r)/m_r*a);
      double y=(m_R-m_r)*MathSin(a)-m_D*MathSin((m_R-m_r)/m_r*a);
      SetPoint(int(m_x0+x),int(m_y0+y));
      a+=m_dAlfa;
     }
   ChartRedraw(0);
  }
//+------------------------------------------------------------------+
//| SetPoint                                                         |
//+------------------------------------------------------------------+
void ISpiro::SetPoint(int x,int y)
  {
   Graph::SetPoint(0,m_sID+"pnt."+string(x)+"."+string(y),0,x,y,m_clr);
  }
//+------------------------------------------------------------------+

Wie Sie sehen können, wurde die verborgene Klasse in einer .mq5-Datei umgesetzt und enthält den Präprozessor-Befehl #property library. Das bedeutet, dass alle im vorherigen Abschnitt dargelegten Regeln beachtet wurden.

Beachten Sie auch den Operator Operation mit Kontexterlaubnis für die Funktion SetPoint. Er wird sowohl in der Bibliothek Graph als auch in der Klasse CSpiro deklariert. Damit der Compiler die erforderliche Funktion aufrufen kann, bestimmen wir sie explizit mit der Operation :: und geben den Dateinamen an.

  Graph::SetPoint(0, m_sID+"pnt."+string(x)+"."+string(y), 0, x, y, m_clr);

Wir können nun die Kopfzeilendatei einfügen und Ihre Umsetzung in den resultierenden Expert Advisor importieren.

Schematisch lässt sich dies wie folgt darstellen:

Schema für die Arbeit mit Methoden der Bibliotheksklassen

Example 5. Using export objects

//--- Spiro.mq5 - the target file of the Expert Advisor

//--- importing some functions
#import "Graph.ex5" 
  void SetLabel(long achart, string name, int wnd, string text, color clr,
               int x, int y, int corn=0, int fontsize=8, string font="Tahoma");
  void SetEdit(long achart, string name, int wnd, string text, color txtclr, color bgclr, color brdclr, 
              int x, int y, int dx, int dy, int corn=0, int fontsize=8, string font="Tahoma", bool ro=false);
  void SetButton(long achart, string name, int wnd, string text, color txtclr, color bgclr, 
                int x, int y, int dx, int dy, int corn=0, int fontsize=8, string font="Tahoma", bool state=false);
  void HideChart(long achart, color BackClr);
#import

//--- including the chart class
#include <Spiro.mqh> 

//--- importing the object
#import "ISpiro.ex5"
  CSpiro *iSpiro();
#import

//--- object instance
CSpiro *spiro; 
//--- prefix for chart objects
string sID; 
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
void OnInit()
{
  HideChart(0, clrWhite);
  sID="spiro.";
  DrawParam();
//--- object instance created
  spiro=iSpiro(); 
//--- initializing the drawing
  spiro.Init(250, 200, clrBlack, sID);
//--- setting the calculation parameters
  spiro.SetData(100, 30, 40, 0.04, 10);
//--- drawing
  spiro.DrawSpiro(); 
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
  delete spiro; // deleting the object
}

Als Ergebnis erhalten Sie die Möglichkeit, die Objektparameter im Diagramm zu ändern und das Diagramm des Objekts zu zeichnen.



Parameter des grafischen Objekts


3. Initialisierung von Variablen in .ex5-Dateien

Es geschieht häufig, dass Ihre ISuperClass Variablen aus der Include-Datei globals.mqh nutzt. Diese Variablen lassen sich ähnlich einbeziehen und in Ihren anderen Dateien verwenden.

Z. B.:

Example 6. Public include file

//--- globals.mqh

#include <Trade\Trade.mqh>
//--- instance of the trade function object
extern CTrade *_trade; 

Die einzige Instanz des Objekts _trade wird in Ihrem Programm initialisiert, wird aber in der verborgenen Klasse ISuperClass verwendet.

Zu diesem Zweck muss ein Pointer zu dem von Ihnen erstellen Objekt von der Klasse ISuperClass an die .ex5-Datei übergeben werden.

Dies lässt sich am einfachsten bewerkstelligen, wenn das Objekt von der .ex5-Datei empfangen wird, wie nachfolgend dargestellt:

Example 7. Initialization of variables upon creation of the object

//--- ISuperClass.mq5 –hidden implementation file

#property library
CSuperClass *iSuperClass(CTrade *atrade) export
{
//--- saving the pointer
   _trade=atrade; 
//--- returning the object of the hidden implementation of ISuperClass of the open CSuperClass class
  return(new ISuperClass); 
}
//... the remaining code

Somit werden alle erforderlichen Variablen beim Empfang des Objekts in seinem Modul initialisiert.

Tatsächlich kann es viele öffentliche globale Variablen geben, die zu verschiedenen Typen gehören können. Wer nicht darauf erpicht ist, die Kopfzeile der Funktion iSuperClass ständig zu ändern, sollte besser eine spezielle Sammelklasse erstellen, die alle globalen Variablen und Funktionen für die Arbeit mit ihr sammelt.

Example 8. Public include file

//--- globals.mqh
#include <Trade\Trade.mqh>

//--- trade "object"
extern CTrade *_trade; 
//--- name of the Expert Advisor of the system
extern string _eaname; 

//+------------------------------------------------------------------+
//| class __extern                                                   |
//+------------------------------------------------------------------+
class __extern // all extern parameters for passing between the ex5 modules are accumulated here
{
public:
//--- the list of all public global variables to be passed
//--- trade "object"
  CTrade *trade; 
//--- name of the Expert Advisor of the system
  string eaname; 
    
public:
  __extern() { };
  ~__extern() { };

//--- it is called when passing the parameters into the .ex5 file
  void Get() { trade=_trade; eaname=_eaname; };  // getting the variables

 //--- it is called in the .ex5 file
  void Set() { _trade=trade; _eaname=eaname; };  // setting the variables
                                                       
};
//--- getting the variables and pointer for passing the object into the .ex5 file
__extern *_GetExt() { _ext.Get(); return(GetPointer(_ext)); } 

//--- the only instance for operation
extern __extern _ext; 
Die Datei ISuperClass.mq5 wird folgendermaßen umgesetzt:
Example 9.

//--- ISuperClass.mq5 –hidden implementation file

#property library
CSuperClass *iSuperClass(__extern *aext) export
{
//--- taking in all the parameters
  aext.Set();//--- returning the object
  return(new ISuperClass); 
}
//--- ... the remaining code

Der Aufruf der Funktion wird nun in eine einfachere und vor allem erweiterbare Variante umgewandelt.

Example 10. Using export objects in the presence of public global variables

//--- including global variables (usually located in SuperClass.mqh)
#include "globals.mqh"    

//--- including the public header class
#include "SuperClass.mqh" 
//--- getting the hidden implementation object
#import "ISuperClass.ex5"
  CSuperClass *iSuperClass();
#import

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
//--- creating the hidden implementation object providing for the passing of all parameters
  CSuperClass *sc=iSuperClass(_GetExt()); 
  //--- ... the remaining code
}


4. Vererbung von Export-Klassen

Es hat sich bereits herauskristallisiert, dass diese Art des Exports von Objekten bedeutet, dass die direkte und einfache Vererbung nicht in Frage kommt. Der Export der verborgenen Umsetzung deutet darauf hin, dass das Objekt selbst das letzte Glied der Vererbungskette ist und letztendlich verwendet werden kann.

Im Allgemeinen können Sie die Vererbung "emulieren", indem Sie eine zusätzliche Zwischenklasse schreiben. Und hier brauchen wir natürlich Polymorphie und Virtualität.

Example 11. Emulation of inheritance of hidden classes

//--- including the public header class
#include "SuperClass.mqh" 

//--- getting the hidden implementation object
#import "ISuperClass.ex5"
  CSuperClass *iSuperClass();
#import

class _CSuperClass
{
public:
//--- instance of the hidden implementation object
  CSuperClass *_base;
public:
//--- constructor
  _CSuperClass() {  _base=iSuperClass(_GetExt()); };
//--- destructor
  ~_CSuperClass() { delete _base; };
//--- further followed by all functions of the base CSuperClass class
//--- working function called from the hidden implementation object
  virtual int func(int a, int b) { _base.func(a,b); }; 
};

Das einzige Problem ist hierbei der Zugriff auf die Variablen von CSuperClass. Wie Sie sehen können, fehlen sie in der Deklarierung des Nachfahren und befinden sich in der Variable _base. Dies wirkt sich für gewöhnlich nicht auf die Benutzerfreundlichkeit aus, solange es die Kopfzeilenklasse SuperClass.mqh gibt.

Wenn Sie sich natürlich hauptsächlich auf Know-how-Funktionen konzentrieren, müssen Sie nicht vorab einen Wrapper von ISuperClass dafür erstellen. Es reicht, diese Know-how-Funktionen zu exportieren und die Fremdentwickler ihre eigenen Wrapper-Klassen erstellen zu lassen, die dann einfach vererbt werden können.

Wenn Sie also Ihre Entwicklungen für andere Entwickler vorbereiten, sollten Sie darauf achten, einen vollständigen Satz von erforderlichen Exportfunktionen, .mqh- und .ex5-Dateien und Klassen zu erstellen:
  1. Export klassenunabhängiger Funktionen
  2. Kopfzeilen-.mqh-Dateien und ihre .ex5-Umsetzungen
  3. Initialisierung von Variablen in den .ex5-Dateien


5. Veröffentlichen von ex5-Bibliotheken

Seit November 2011 bietet MetaQuotes einen Zugang zu einer Dateiablage. Mehr dazu finden Sie in der Ankündigung.

In dieser Ablage können Sie Ihre Entwicklungen speichern und, noch viel wichtiger, anderen Entwicklern den Zugriff darauf gewähren. Mit diesem Tool können Sie schnell und einfach neue Versionen Ihrer Dateien veröffentlichen, um Entwicklern, die diese Dateien möglicherweise nutzen, den schnellen Zugriff darauf zu ermöglichen.

Zudem liefert Ihnen die Webseite des Unternehmens eine Möglichkeit, Ihre eigenen Funktionsbibliotheken kommerziell oder kostenlos im Market anzubieten.


Fazit

Sie wissen nun, wie ex5-Bibliotheken mit dem Export ihrer Funktionen und Klassenobjekte erstellt werden, und können Ihr Wissen praktisch anwenden. Dank diesen Ressourcen können Sie enger mit anderen Entwicklern kooperieren, um an gemeinsamen Projekten zu arbeiten, sie auf dem Market zu bewerben oder Zugriff auf ex5-Bibliotheksfunktionen zu gewähren.


Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/362

Beigefügte Dateien |
spiro.zip (3.91 KB)
Schutz von MQL5-Programmen: Passwörter, Schlüssel, Zeitbegrenzung, Berechtigungsfernabfrage Schutz von MQL5-Programmen: Passwörter, Schlüssel, Zeitbegrenzung, Berechtigungsfernabfrage

Die Mehrzahl der Entwickler benötigt Schutz für ihren Programmcode. In diesem Beitrag werden einige unterschiedliche Möglichkeiten zum Schutz von in MQL5 geschriebenen Programmen vorgestellt, so etwa zur Ausstattung von MQL5-Skripten, automatischen Handelssystemen und Indikatoren mit Zugriffskontrollverfahren. Dazu zählen Passwortschutz, Schlüsselgeneratoren, Zugriffskonten, Zeitbegrenzungsprüfungen sowie der Schutz mittels MQL5-RPC-Aufrufen aus der Ferne.

Trademinator 3: Aufstand der Handelsrobots Trademinator 3: Aufstand der Handelsrobots

In dem Beitrag „Dr. Tradelove...“ haben wir ein Expert-System angelegt, das die Parameter eines vorher ausgewählten automatischen Handelssystems unabhängig optimiert. Mehr noch, wir haben beschlossen, ein Expert-System zu schaffen, das nicht nur die Parameter des einen, ihm zugeordneten Handelssystems optimieren kann, sondern auch unter mehreren das beste Handelssystem auswählen kann. Schauen wir uns an, wozu es im Stande ist...

Der letzte Kreuzzug Der letzte Kreuzzug

Sehen Sie sich Ihr Handelsterminal an. Welche Mittel zur Darstellung von Preisen können Sie sehen? Balken, Kerzen, Linien. Wir jagen Zeit und Preisen hinterher, während wir nur von Preisen profitieren können. Sollen wir nur auf Preise achten, wenn wir den Markt analysieren? Dieser Beitrag schlägt einen Algorithmus und ein Script für Punkt- und Zeichendiagramme ("X und O") vor. Es werden unterschiedliche Preismuster betrachtet, deren praktische Anwendung in den bereitgestellten Empfehlungen erläutert wird.

AutoElliottWaveMaker - ein Tool für die halbautomatisierte Analyse von Elliott-Wellen in MetaTrader 5 AutoElliottWaveMaker - ein Tool für die halbautomatisierte Analyse von Elliott-Wellen in MetaTrader 5

Dieser Beitrag liefert einen Überblick über AutoElliottWaveMaker, das erste Werkzeug für die Analyse von Elliott-Wellen in MetaTrader 5, das eine Kombination aus manueller und automatischer Kennzeichnung von Wellen darstellt. Das Wellenanalyse-Tool ist ausschließlich in MQL5 geschrieben und enthält keine externen DLL-Bibliotheken. Das ist ein weiterer Beleg dafür, dass ausgeklügelte und interessante Programme in MQL5 entwickelt werden können (und sollten).