Integration von MQL-basierten Expert Advisors und Datenbanken (SQL Server, .NET und C#)

Сергей Ткаченко | 12 September, 2018

Einführung, Experten für MQL und Datenbanken

In den Foren erscheinen oft Fragen zur Integration einer Datenbank in einen Expert Advisor in MQL5. Das Interesse an diesem Thema ist nicht überraschend. Datenbanken sind sehr gut geeignet, Daten zu speichern. Im Gegensatz zu den Logdateien des Terminals verschwinden die Daten einer Datenbank nicht. Sie sind einfach zu sortieren, zu filtern und gewünschten lassen sich leicht auswählen. Eine Datenbank kann verwendet werden, um die notwendigen Informationen an einen Experten weiterzugeben - zum Beispiel bestimmte Befehle. Und vor allem - die gewonnenen Daten können aus verschiedenen Perspektiven analysiert und statistisch verarbeitet werden. Das Schreiben einer einzeiligen Abfrage reicht beispielsweise aus, um den durchschnittlichen und den Gesamtgewinn für eine bestimmte Zeit für jedes Währungspaar zu ermitteln. Und stellen Sie sich nun vor, wie lange es dauern würde, wenn Sie dies für die Handelshistorie eines Kontos im Terminal manuell einrichten müssten.

Leider bietet MetaTrader keine integrierten Werkzeuge für die Verwendung von Datenbankservern. Das Problem kann nur durch den Import von Funktionen aus DLL-Dateien gelöst werden. Die Aufgabe ist nicht einfach, aber machbar.

Ich habe dies mehrmals getan, und ich habe beschlossen, meine Erfahrungen in diesem Artikel zu teilen. So ist beispielsweise die Interaktion von MQL5-Experten mit dem Microsoft SQL Server Datenbankserver organisiert. Um eine DLL-Datei für die Experten zu erstellen, die Funktionen für die Arbeit mit der Datenbank importieren, wurde die Microsoft.NET-Plattform und die Sprache C# verwendet. Der Artikel beschreibt den Prozess der Erstellung und Vorbereitung einer DLL-Datei und anschließend den Import ihrer Funktionen in einen in MQL5 geschriebenen Experten. Der als Beispiel angegebene Expertencode ist sehr einfach. Es sind nur minimale Änderungen erforderlich, damit er auch in MQL4 kompiliert werden kann.

Arbeitsvorbereitung

Die folgenden Punkte werden für die Arbeit benötigt.

1. Ein installiertes MetaTrader 5 Terminal mit einem aktiven Handelskonto. Sie können nicht nur Demokonten, sondern auch reale Konten verwenden - die Verwendung des Testexperten stellt kein Risiko für die Einzahlung dar.
   
2. Ein installierte Instanz des Microsoft SQL Server Datenbankservers. Sie können eine Datenbank auf einem anderen Computer verwenden und sich über das Netzwerk mit ihr verbinden. Die kostenlose Express Edition kann von der Microsoft-Website heruntergeladen werden, ihre Einschränkungen sind für die meisten Benutzer nicht von Bedeutung. Sie können es von hier herunterladen: https://www.microsoft.com/en-us/sql-server/sql-server-editions-express. Microsoft ändert aber manchmal die Links auf seiner Website. Wenn der direkte Link nicht funktioniert, geben Sie einfach einen Ausdruck wie "SQL Server Express download" in eine Suchmaschine ein. Wenn Sie SQL Server zum ersten Mal installieren, kann es zu einigen Schwierigkeiten bei der Installation kommen. Insbesondere kann es erforderlich sein, dass zusätzliche Komponenten (insbesondere PowerShell und .NET 4.5) auf älteren Versionen des Betriebssystems installiert werden. Außerdem können SQL Server und VS C++ 2017 manchmal Konflikte verursachen, wobei das Installationsprogramm die Wiederherstellung von С++ anfordert. Sie können dies über "Systemsteuerung", "Programme", "Programme und Funktionen", "VS C++ 2017", "Ändern", "Reparieren" tun. Diese Probleme treten nicht immer auf und können leicht gelöst werden.
   
3. Integrierte Entwicklungsumgebung mit .NET und C#. Ich benutze persönlich Microsoft Visual Studio (das auch eine kostenlose Version hat), daher werden die Beispiele dafür angegeben. Sie können eine andere Entwicklungsumgebung und sogar eine andere Programmiersprache verwenden. Aber dann müssen Sie sich überlegen, wie Sie die gegebenen Beispiele in der Umgebung und der Sprache Ihrer Wahl umsetzen können.
4. Tool zum Exportieren von Funktionen aus DLL-Dateien, die in .NET geschrieben wurden, für andere Programmiersprachen. MQL-basierte Experten können nicht mit .NET-Code arbeiten. Daher sollte die resultierende DLL-Datei speziell vorbereitet werden, um Funktionen exportieren zu können. Im Web werden verschiedene Möglichkeiten beschrieben, dies zu erreichen. Ich habe das Paket "UnmanagedExports" von Robert Giesecke verwendet. Wenn Sie Microsoft Visual Studio Version 2012 oder höher verwenden, können Sie es direkt aus dem IDE-Menü zum Projekt hinzufügen. Wie dies erreicht wird, wird weiter unten besprochen.

Neben der Installation der erforderlichen Programme ist es auch notwendig, eine weitere vorbereitende Operation durchzuführen. Aus verschiedenen Gründen kann "UnmanagedExports" nicht funktionieren, wenn in den Spracheinstellungen Ihres Computers "Russisch (Russland)" als Sprache für Nicht-Unicode-Programme ausgewählt ist. Es kann auch mit anderen Sprachen Probleme geben, es sei denn, es handelt sich um "Englisch (US)". Um das zu installieren, öffnen Sie das Bedienfeld. Navigieren Sie zur Registerkarte "Regional and Language Options" und gehen Sie dann zur Registerkarte "Advanced". Sie auf der Registerkarte "language for non-Unicode programs" auf "Change system locale...". Wenn dort "English (US)" eingestellt ist, ist alles in Ordnung. Wenn es noch etwas gibt, ändern Sie es in "English (US)" und starten Sie den Computer neu.

Wenn dies nicht geschieht, tritt bei der Kompilierung des Projekts in der Ausführungsphase der Skripte "UnmanagedExports" ein Syntaxfehler in den Dateien ".il" auf. Diese können nicht korrigiert werden. Selbst wenn Ihr Projekt sehr einfach ist und es sicherlich keine Fehler im C#-Code gibt, treten immer noch Fehler in ".il"-Dateien auf, und dann kann man die Funktionen aus dem Projekt nicht in nicht verwalteten Code exportieren.

Dies gilt nur für 64-Bit-Anwendungen. 32-Bit-Anwendungen können mit anderen Mitteln behandelt werden, die keine Änderung des Gebietsschemas (system locale) erfordern. Sie können beispielsweise das Programm DllExporter.exe verwenden, das Sie hier herunterladen können: https://www.codeproject.com/Articles/37675/Simple-Method-of-DLL-Export-without-C-CLI.

Das Ändern des Gebietsschemas führt dazu, dass einige Anwendungen inoperabel sind. Leider müssen diese Unannehmlichkeiten überwunden werden, aber es dauert nicht lange. Das Ändern des Gebietsschemas ist nur notwendig, wenn Sie das Projekt kompilieren. Nach erfolgreicher Kompilierung kann das Gebietsschema wieder zurückgeschaltet werden.

Erstellen einer DLL-Datei

Öffnen Sie Visual Studio und erstellen Sie ein neues Visual C#-Projekt, indem Sie "Class Library" als Typ auswählen. Wir nennen es MqlSqlDemo. In den Projekteigenschaften, im Abschnitt "Build", ist es notwendig, das "Platform target" zu konfigurieren. Dort ist es notwendig, "Any CPU" auf "x64" zu ändern (sowohl in der Debug-Konfiguration als auch in der Release-Konfiguration). Dies liegt an den Besonderheiten beim Export von Funktionen in 'unmanaged' Code - die Angabe des Prozessortyps ist zwingend erforderlich.

Installieren Sie das.NET-Framework Version 4.5. Es ist in der Regel standardmäßig ausgewählt.

Beim Erstellen eines Projekts wird die Datei "Class1.cs" mit der Klasse "Class1" automatisch dem Projekt hinzugefügt. Benennen Sie sowohl die Datei als auch die Klasse in "MqlSqlDemo.cs" und "MqlSqlDemo" um. Funktionen, die aus der DLL-Datei exportiert werden sollen, können nur statisch sein - dies ist wiederum für den Export in nicht 'unmanaged' Code erforderlich.

Streng genommen können Sie auch nicht-statische Funktionen exportieren. Aber um dies zu tun, ist es notwendig, auf C++/CLI-Tools zu verweisen, die in diesem Artikel nicht berücksichtigt werden.

Da alle Funktionen in unserer Klasse statisch sein müssen, ist es logisch, die Klasse selbst statisch zu machen. In diesem Fall, wenn für eine Funktion der Modifikator "static" fehlt, wird dies sofort beim Kompilieren des Projekts festgestellt. Wir erhalten die folgende Klassendefinition:

public static class MqlSqlDemo
{
    // ...
}

Nun müssen die Abhängigkeiten des Projekts konfiguriert werden (Abschnitt "References" im "Solution Explorer"). Wir entfernen alle redundanten Optionen, so dass nur "System" und "System.Data" übrig bleiben.

Jetzt kann das Paket "UnmanagedExports" hinzugefügt werden.

Die Beschreibung des Pakets steht auf der Seite des Autors: https://sites.google.com/site/robertgiesecke/Home/uploads/unmanagedexports.

Der einfachste Weg, es hinzuzufügen, ist die Verwendung des NuGet-Paketmanagers. Anweisungen zum Hinzufügen finden Sie auf der NuGet-Seite: https://www.nuget.org/packages/UnmanagedExports

In unserem Fall wird nur eine dieser Anweisungen benötigt:

Install-Package UnmanagedExports -Version 1.2.7

Wählen Sie im Menü von Visual Studio die Abschnitte "Tools", dann "NuGet Package Manager" und "Package Manager Console". Die Befehlszeile wird unten angezeigt. Fügen Sie dort die kopierte Anleitung "Install-Package UnmanagedExports - Version 1.2.7" ein und drücken Sie "Enter". Der Paketmanager verbindet sich für eine Weile mit dem Internet, lädt das Paket herunter, fügt es dann dem Projekt hinzu und druckt Folgendes aus:

PM> Install-Package UnmanagedExports -Version 1.2.7
Installing 'UnmanagedExports 1.2.7'.
Successfully installed 'UnmanagedExports 1.2.7'.
Adding 'UnmanagedExports 1.2.7' to MqlSqlDemo.
Successfully added 'UnmanagedExports 1.2.7' to MqlSqlDemo.

PM> 

Dies bedeutet, dass das Paket erfolgreich hinzugefügt wurde.

Danach können wir den Code direkt in die Klassendefinitionsdatei MqlSqlDemo.cs schreiben.

Konfigurieren wir die verwendeten Namensräume (namespaces).

• Visual Studio fügt viele zusätzliche hinzu. Entfernen Sie im Abschnitt "using" alles außer "using System;".
  
• Fügen Sie dann "using System.Data;" hinzu - hier werden die Klassen für die Arbeit mit den Datenbanken übernommen.
  
• Fügen Sie hier "using System.Data.SqlClient;" hinzu: Hier sind die speziellen Klassen für das Arbeiten mit der SQL Server-Datenbank.
  
• Fügen Sie "using System.Runtime.InteropServices;" hinzu: hier sind die Attribute für die Interaktion mit dem nicht 'unmanaged' Code.
• Fügen Sie "using RGiesecke.DllExport;" hinzu: Das Attribut zur Markierung der exportierten Funktionen wird von hier übernommen.

using System;
using System.Data;
using System.Data.SqlClient;
using System.Runtime.InteropServices;
using RGiesecke.DllExport;

private static SqlConnection conn = null;
private static SqlCommand com = null;

private static string sMessage = string.Empty;

public const int iResSuccess = 0;
public const int iResError = 1;

[DllExport("CreateConnection", CallingConvention = CallingConvention.StdCall)]
    public static int CreateConnection(
            [MarshalAs(UnmanagedType.LPWStr)] string sConnStr)
    {
        // Zeichenkette der Nachricht löschen:
        sMessage = string.Empty;
        // Bei Verbindung - schließen und erneuern
        // der Zeichenkette der Verbindung, wenn nicht -
        // erneuern der Objekte von Verbindung und Command:
        if (conn != null)
        {
                conn.Close();
                conn.ConnectionString = sConnStr;
        }
        else
        {
                conn = new SqlConnection(sConnStr);
                com = new SqlCommand();
                com.Connection = conn;
        }
        // Öffnungsversuch der Verbindung:
        try
        {
                conn.Open();
        }
        catch (Exception ex)
        {
                // Verbindung öffnete sich nicht, warum auch immer.
                // Fehlermeldung in die Zeichenkette der Nachricht schreiben:
                sMessage = ex.Message;
                // Ressourcen freigeben und Objekte zurücksetzen:
                com.Dispose();
                conn.Dispose();
                conn = null;
                com = null;
                // Error:
                return iResError;
        }
        // Alles ging gut, Verbindung ist offen:
        return iResSuccess;
}

[DllExport("GetLastMessage", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.LPWStr)]
public static string GetLastMessage()
{
        return sMessage;
}

[DllExport("ExecuteSql", CallingConvention = CallingConvention.StdCall)]
public static int ExecuteSql(
        [MarshalAs(UnmanagedType.LPWStr)] string sSql)
{
        // Zeichenkette der Nachricht löschen:
        sMessage = string.Empty;
        // Zuerst prüfen, ob die Verbindung steht.
        if (conn == null)
        {
                // Die Verbindung ist noch nicht offen.
                // Fehlermeldung und Rückgabe des Fehlerflags:
                sMessage = "Connection is null, call CreateConnection first.";
                return iResError;
        }
        // Die Verbindung steht, versuchen wir die Ausführung eines Befehls.
        try
        {
                com.CommandText = sSql;
                com.ExecuteNonQuery();
        }
        catch (Exception ex)
        {
                // Fehler bei der Befehlsausführung.
                // Fehlermeldung in die Zeichenkette der Nachricht schreiben:
                sMessage = ex.Message;
                // Rückgabe des Fehlerflags:
                return iResError;
        }
        // Alles ging gut - Rückgabe des Erfolgsflags:
        return iResSuccess;
}

[DllExport("ReadInt", CallingConvention = CallingConvention.StdCall)]
public static int ReadInt(
        [MarshalAs(UnmanagedType.LPWStr)] string sSql)
{
        // Zeichenkette der Nachricht löschen:
        sMessage = string.Empty;
        // Zuerst prüfen, ob die Verbindung steht.
        if (conn == null)
        {
                // Die Verbindung ist noch nicht offen.
                // Fehlermeldung und Rückgabe des Fehlerflags:
                sMessage = "Connection is null, call CreateConnection first.";
                return iResError;
        }
        // Variable für die Ergebnisrückgabe:
        int iResult = 0;
        // Die Verbindung steht, versuchen wir die Ausführung eines Befehls.
        try
        {
                com.CommandText = sSql;
                iResult = (int)com.ExecuteScalar();
        }
        catch (Exception ex)
        {
                // Fehler bei der Befehlsausführung.
                // Fehlermeldung in die Zeichenkette der Nachricht schreiben:
                sMessage = ex.Message;
        }
        // Rückgabe des erhaltenen Ergebnisses:
        return iResult;
}

[DllExport("ReadString", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.LPWStr)]
public static string ReadString(
        [MarshalAs(UnmanagedType.LPWStr)] string sSql)
{
        // Zeichenkette der Nachricht löschen:
        sMessage = string.Empty;
        // Zuerst prüfen, ob die Verbindung steht.
        if (conn == null)
        {
                // Die Verbindung ist noch nicht offen.
                // Fehlermeldung und Rückgabe des Fehlerflags:
                sMessage = "Connection is null, call CreateConnection first.";
                return string.Empty;
        }
        // Variable für die Ergebnisrückgabe:
        string sResult = string.Empty;
        // Die Verbindung steht, versuchen wir die Ausführung eines Befehls.
        try
        {
                com.CommandText = sSql;
                sResult = com.ExecuteScalar().ToString();
        }
        catch (Exception ex)
        {
                // Fehler bei der Befehlsausführung.
                // Fehlermeldung in die Zeichenkette der Nachricht schreiben:
                sMessage = ex.Message;
        }
        // Rückgabe des erhaltenen Ergebnisses:
        return sResult;
}

[DllExport("CloseConnection", CallingConvention = CallingConvention.StdCall)]
public static void CloseConnection()
{
        // Zuerst prüfen, ob die Verbindung steht.
        if (conn == null)
                // Die Verbindung ist noch nicht offen - heißt, sie muss nicht geschlossen werden:
                return;
        // Die Verbindung ist offen - sie muss geschlossen werden.
        com.Dispose();
        com = null;
        conn.Close();
        conn.Dispose();
        conn = null;
}

Erstellen eines Expert Advisors in MQL5

Erstellen wir einen einfachen Experten für MQL5. Sein Code kann auch im MQL4-Editor kompiliert werden, indem die Erweiterung von "mq5" auf "mq4" geändert wird. Dieser Experte dient nur zur Demonstration der erfolgreichen Arbeit mit der Datenbank, er führt daher keine Handelsoperationen durch.

Starten Sie den MetaEditor, drücken Sie die Schaltfläche "Neu". Wählen Sie "Expert Advisor (Vorlage)" und drücken Sie "Weiter". Geben Sie den Namen "MqlSqlDemo" an. Füge auch einen Parameter hinzu - "ConnectionString" vom Typ "string". Dies ist die Verbindungszeichenfolge, die angibt, wie Sie sich mit Ihrem Datenbankserver verbinden. So können Sie beispielsweise diesen Initialwert für den Parameter einstellen:

Server=localhost;Database=master;Integrated Security=True

Diese Zeichenkette für die Verbindung ermöglicht die Verbindung zu einem unbenannten ("Default Instance") Datenbankserver, der auf demselben Computer installiert ist, auf dem das MetaTrader-Terminal läuft. Es ist nicht erforderlich, Login und Passwort anzugeben — es wird die Autorisierung durch das Windows-Konto verwendet.

Wenn Sie SQL Server Express heruntergeladen und auf Ihrem Computer installiert haben, ohne die Parameter zu ändern, dann ist Ihr SQL Server eine "benannte Instanz". Sie erhält den Namen "SQLEXPRESS". Sie wird eine andere Zeichenkette für die Verbindung erhalten:

Server=localhost\\SQLEXPRESS;Database=master;Integrated Security=True

Wenn Sie einen Zeichenkettenparameter zur Vorlage des Expert Advisors hinzufügen, ist die Länge der Zeichenkette beschränkt. Eine längere Zeichenkette für die Verbindung (z.B. zu einem benannten Server "SQLEXPRESS") passt möglicherweise nicht. Aber das ist kein Problem - der Parameterwert kann zu diesem Zeitpunkt leer gelassen werden. Er kann später bei der Bearbeitung des Expertencodes auf einen beliebigen Wert geändert werden. Es ist auch möglich, beim Start des Experten die gewünschte Zeichenkette der Verbindung anzugeben.

Klicken Sie auf "Weiter". Es müssen keine weiteren Funktionen hinzugefügt werden, also lassen wir alle Kontrollkästchen auf dem nächsten Bildschirm deaktiviert. Drücken Sie erneut "Weiter" und erhalten Sie den generierten Anfangscode des Experten.

Der Zweck des Experten ist es nur, die Verbindung zur Datenbank nachzuweisen und damit zu arbeiten. Dazu genügt es, nur die Initialisierungsfunktion — OnInit — zu verwenden. Entwürfe für andere Funktionen — OnDeinit und OnTick — können sofort entfernt werden.

Als Ergebnis erhalten wir folgendes:

//+------------------------------------------------------------------+
//|                                                   MqlSqlDemo.mq5 |
//|                        Copyright 2018, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
//--- Eingabeparameter
input string   ConnectionString = "Server=localhost\\SQLEXPRESS;Database=master;Integrated Security=True";
//+------------------------------------------------------------------+
//| Initialisierungsfunktion des Experten                            |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

//---
   return(INIT_SUCCEEDED);
  }

Bitte beachten Sie: Bei der Verbindung zu einer benannten Instanz (in diesem Fall "SQLEXPRESS") ist es notwendig, das Zeichen "\" zweimal zu wiederholen: "localhost\\SQLEXPRESS". Dies ist sowohl beim Hinzufügen des Parameters zur Expertenvorlage als auch im Code erforderlich. Wird das Zeichen nur einmal angegeben, behandelt der Compiler es so, als ob die Escape-Sequenz (Sonderzeichen) "\S" in der Zeichenkette angegeben wäre, und meldet, dass es bei der Kompilierung nicht erkannt wurde.

Wenn Sie jedoch einen kompilierten Roboter an ein Diagramm anhängen, haben seine Parameter nur ein "\"-Zeichen, obwohl zwei von ihnen im Code angegeben sind. Dies geschieht, weil alle Escape-Sequenzen in Zeichenketten während der Kompilierung in entsprechende Zeichen umgewandelt werden. Die Sequenz "\\" wird in ein einziges "\"-Zeichen umgewandelt, und Benutzer (die nicht mit dem Code arbeiten müssen) sehen die normale Zeichenkette. Wenn Sie also die Verbindungszeichenfolge nicht im Code, sondern beim Start des Expert Advisors angeben, sollte nur ein einziges "\"-Zeichen in der Verbindungszeichenfolge angegeben werden.

Server=localhost\SQLEXPRESS;Database=master;Integrated Security=True

Fügen wir das nun dem Entwurf des Experten die Funktionen hinzu. Zunächst ist es notwendig, die Funktionen für die Arbeit mit der Datenbank aus der erstellten DLL zu importieren. Fügen wir den Importabschnitt vor der Funktion OnInit() hinzu. Die importierten Funktionen werden fast so beschrieben, wie sie im C#-Code deklariert sind. Es ist nur notwendig, alle Modifikatoren und Attribute zu entfernen:

// Beschreibung der importierten Funktionen.
#import "MqlSqlDemo.dll"

// Funktion zum Öffnen der Verbindung:
int CreateConnection(string sConnStr);
// Funktion zum Lesen der letzten Nachricht:
string GetLastMessage();
// Funktion zum Ausführen eines Befehls:
int ExecuteSql(string sSql);
// Funktion zum Lesen einer Ganzzahl:
int ReadInt(string sSql);
// Funktion zum Lesen einer Zeichenkette:
string ReadString(string sSql);
// Funktion zum Öffnen der Verbindung:
void CloseConnection();

// Ende des Imports:
#import

Zur besseren Übersichtlichkeit des Codes deklarieren wir die Konstanten der Ergebnisse der Ausführung von Funktionen. Wie in der DLL ist dies 0 bei erfolgreicher Ausführung und 1 bei einem Fehler:

// Erfolgreiche Ausführung einer Funktion
#define iResSuccess  0
// Fehler bei Funktionsausführung:
#define iResError 1

Jetzt können wir Funktionsaufrufe zur Datenbankabfrage der Initialisierungsfunktion OnInit() hinzufügen. So sieht das dann aus:

int OnInit()
  {
   // Versuch einer Verbindungseröffnung:
   if (CreateConnection(ConnectionString) != iResSuccess)
   {
      // Fehler bei Verbindungseröffnung.
      // Nachricht ausdrucken und beenden:
      Print("Error when opening connection. ", GetLastMessage());
      return(INIT_FAILED);
   }
   Print("Connected to database.");
   // Die Verbindung wurde erfolgreich eröffnet.
   // Versuch eine Ausführung einer Abfrage.
   // Tabelle erstellen und Einschreiben der Daten:
   if (ExecuteSql(
      "create table DemoTest(DemoInt int, DemoString nvarchar(10));")
      == iResSuccess)
      Print("Created table in database.");
   else
      Print("Failed to create table. ", GetLastMessage());
   if (ExecuteSql(
      "insert into DemoTest(DemoInt, DemoString) values(1, N'Test');")
      == iResSuccess)
      Print("Data written to table.");
   else
      Print("Failed to write data to table. ", GetLastMessage());
   // Lesen der Daten. Lesen einer Ganzzahl aus der Datenbank:
   int iTestInt = ReadInt("select top 1 DemoInt from DemoTest;");
   string sMessage = GetLastMessage();
   if (StringLen(sMessage) == 0)
      Print("Number read from database: ", iTestInt);
   else // Failed to read number.
      Print("Failed to read number from database. ", GetLastMessage());
   // Lesen einer Zeichenkette:
   string sTestString = ReadString("select top 1 DemoString from DemoTest;");
   sMessage = GetLastMessage();
   if (StringLen(sMessage) == 0)
      Print("String read from database: ", sTestString);
   else // Failed to read string.
      Print("Failed to read string from database. ", GetLastMessage());
   // Die Tabelle wird nicht mehr benötigt - sie kann gelöscht werden.
   if (ExecuteSql("drop table DemoTest;") != iResSuccess)
      Print("Failed to delete table. ", GetLastMessage());
   // Aufgabe erfüllt - Verbindung schließen:
   CloseConnection();
   // Initialisierung beenden:
   return(INIT_SUCCEEDED);
  }

Kompilieren wir den Experten. Das war's, der Testexperte ist bereit. Wir können ihn laufen lassen. Bevor wir den Experten ausführen, ist es notwendig, die DLL in den Bibliotheksordner des von uns verwendeten MetaTrader-Profils hinzuzufügen. Starten Sie MetaTrader, wählen Sie im Menü "Datei" die Option "Datenordner öffnen". Öffnen Sie den Ordner "MQL5" (für MetaTrader 4 den Ordner "MQL4"), dann den Ordner "Libraries". Kopieren Sie die erstellte DLL-Datei (MqlSqlDemo.dll) in diesen Ordner. Der Experte sollte bereits zu diesem Zeitpunkt kompiliert und einsatzbereit sein. Natürlich sollte das Ausführen eines Expert Advisors und das Importieren von Funktionen aus der DLL in den MetaTrader 5 Einstellungen erlaubt sein, sonst gibt es sofort beim Start einen Fehler.

Starten Sie den Experten und ändern Sie die Werte der Verbindungszeichenfolge in die Zugriffsparameter Ihres Datenbankservers. Wenn alles richtig gemacht wird, gibt der Experte folgendes im Protokoll aus:

Die Verbindung zur Datenbank, das Ausführen der SQL-Kommandos, das Lesen und Schreiben der Daten — alles wurde erfolgreich ausgeführt.

Schlussfolgerung

Eine Komplettlösung für Visual Studio - das Archiv mit allen notwendigen Dateien ist dem Artikel unter dem Namen "MqlSqlDemo.zip" angehängt. Das Paket "UnmanagedExports" ist bereits installiert. Der Testexperte MqlSqlDemo.mq5 und seine Variante für MQL4 befinden sich im Unterordner "MQL".

Der in diesem Artikel beschriebene Ansatz ist voll funktionsfähig. Basierend auf den oben genannten Prinzipien wurden Anwendungen entwickelt, die es ermöglichen, mit Tausenden und sogar Zehntausenden von gleichzeitig gestarteten Experten zu arbeiten. Alles wurde mehrfach getestet und funktioniert bis heute.

Sowohl die DLL-Datei als auch der in diesem Artikel erstellte Experte sind nur für Bildungs- und Evaluierungszwecke bestimmt. Natürlich können Sie die DLL auch in realen Projekten verwenden. Es ist jedoch sehr wahrscheinlich, dass sie aufgrund seiner erheblichen Einschränkungen bald nicht mehr ausreicht. Wenn Sie Ihren Experten die Möglichkeit geben möchten, mit Datenbanken zu arbeiten, werden Sie höchstwahrscheinlich mehr Funktionen benötigen. In diesem Fall ist es notwendig, den Code selbst hinzuzufügen, wobei dieser Artikel als Beispiel dient. Wenn Sie irgendwelche Schwierigkeiten haben, bitten Sie um Hilfe in den Kommentaren zum Artikel, kontaktiere Sie mich über Skype (cansee378) oder über die Kontaktseite auf meiner Website: http://life-warrior.org/contact.

Wenn Sie nicht die Zeit oder den Wunsch haben, den C#-Code durchzugehen, können Sie das fertige Projekt herunterladen. Das kostenlose Open-Source-Programm namens HerdOfRobots ist nach den gleichen Prinzipien implementiert, die im Artikel beschrieben sind. Das Installationspaket enthält die kompletten Dateien mit den importierten Funktionen sowohl für MetaTrader 5 als auch für MetaTrader 4 zusammen mit dem Programm. Diese Bibliotheken verfügen über wesentlich leistungsfähigere Funktionen. So können beispielsweise bis zu 63 Experten in einem Terminal (das mit verschiedenen Datenbanken verbunden sein kann) arbeiten, Daten aus Tabellen Zeile für Zeile lesen, Datums-/Uhrzeitwerte in die Datenbank schreiben.

Das Programm HerdOfRobots bietet komfortable Funktionen zur Steuerung der mit der Datenbank verbundenen Experten und zur Analyse der von ihnen geschriebenen Daten. Das Paket enthält ein Handbuch, das alle Aspekte der Arbeit sehr detailliert beschreibt. Das Archiv mit dem Programm Installer - SetupHerdOfRobots.zip - ist ebenfalls dem Artikel beigefügt. Wenn Sie den Code des Programms sehen möchten, das für die Verbindung zur Datenbank des MqlToSql64-Projekts (MqlToSql für MT4) verwendet wird, um die genannten erweiterten Funktionen später in Ihren Projekten zu nutzen, kann der Code kostenlos aus offenen Repositorien heruntergeladen werden:

https://bitbucket.org/CanSeeThePain/herdofrobots

https://bitbucket.org/CanSeeThePain/mqltosql64

https://bitbucket.org/CanSeeThePain/mqltosql