.Net — это патентованное название общеязыковой платформы от компании Microsoft. Она была создана в 2002 году как альтернатива популярной в то время, впрочем как и сейчас, платформе Java. Основу платформы составляет так называемая общеязыковая среда исполнения  Common Language Runtime или CLR. В отличии от классической программы, которая компилируется непосредственно в машинный код, и может быть запущена на компьютере напрямую, программа написанная для .Net запускается на виртуальной машине CLR.  Таким образом .Net — это некая среда, с помощью которой программа, написанная на языке высокого уровня, выполняется на машине пользователя.

Язык программирования C# является основным языком программирования в Net. Когда говорят о C# подразумевают Net, и напротив — Net четко ассоциируется с C#. Упрощенно можно сказать, что Net — это среда исполнения программ, написанных как правило на C#. Наша статья не будет исключением. Весь код, предложенный в статье, будет написан на этом языке.

После того, как программа для платформы .Net написана, она компилируется в некий промежуточный байт код низкоуровневого языка CIL (Common Intermediate Language), который исполняет виртуальная машина CLR. Сам код упаковывается в стандартные сущности windows-программ: исполняемые модули exe или динамические библиотеки dll. Скомпилированный код для виртуальной машины Net имеет высокоуровневую структуру, его свойства легко исследовать, можно понять какие типы данных он содержит. Эту замечательную особенность используют последние версии компилятора MQL. Компилятор, на этапе компиляции, загружает динамическую библиотеку Net, и читает общедоступные статические методы, определенные в ней. Помимо открытых статических методов, компилятор MQL понимает базовые типы данных языка программирования C#. К этим типам данным относятся:

• Все целочисленные типы данных: long/ulong, int/uint, byte, short/ushort;
• Вещественные числа с плавающей запятой float/double;
• Символьный тип данных char (в отличии от MQL, где char и uchar означают байтовый тип данных, в С# данный тип используется для определения символа);
• Строковые типы string;
• Простые структуры, содержащие в качестве своих полей базовые типы перечисленные выше.

Схема представлена в самом общем виде, и пока не раскрывает конкретики взаимодействия между описанными частями нашего будущего графического приложения. Однако, исходя из предложенной схемы, становится ясно, что наша система будет высокораспределенной: каждый модуль будет независимым и не будет требовать вмешательства в свой код, если какой-либо другой модуль претерпел изменения. В следующих разделах будет подробно описан сам процесс взаимодействия между этими частями и те средства, с помощью которых это разделение будет реализовано.

Установка и настройка Visual Studio

Теперь, когда общая схема реализации подготовлена, настало время приступить к непосредственной реализации нашего проекта. Для этого на компьютере необходимо иметь рабочую версию Visual Studio. Если эта программа у Вас уже установлена, Вы можете пропустить данный раздел. Однако для новичков или тех, кто еще никогда не сталкивался с данной программой, этот раздел будет полезен. 

Visual Studio представляет из себя профессиональную среду разработки в самых разнообразных областях программирования. Данный комплекс представлен в нескольких редакциях. Нас будет интересовать редакция Community. Данная версия является условно-бесплатной. После тридцати дней использования, ее необходимо бесплатно зарегистрировать, для чего пройти стандартную процедуру верификации с помощью одного из сервиса Microsoft. Мы покажем основные шаги по скачиванию, установке и регистрации платформы, чтобы начинающие пользователи могли безболезненно начать использовать ее функционал в кратчайшие сроки. 

Итак, приведем пошаговое руководство для установки Visual Studio на компьютер. Далее будут представлены скриншоты для международной английской версии инсталлятора. Конкретный внешний вид в Вашем случае может отличаться, в зависимости от региональных настроек Вашего компьютера. 

Первое, что необходимо сделать — это перейти на официальный сайт Visual Studio visualstudio.microsoft.com и выбрать подходящий дистрибутив. Напоминаю, что нам необходимо выбрать версию Community:

 

Рис. 2. Выбор дистрибутива VisualStudio.

После выбора начнется процесс скачивания установщика Visual Studio. Если сайт предложит Вам зарегистрироваться, пропустите этот шаг. Мы выполним эту процедуру позже.

После запуска инсталлятора появится окно, которое предупредит о том, что потребуется выполнить определенную конфигурацию Вашего инсталлятора. Необходимо согласится с предложением и нажать кнопку Сontinue:

Рис. 3. Согласие на продолжение установки

Далее начнется процесс скачивания необходимых файлов для установки. Он может занять некоторое время, в зависимости от пропускной способности Вашего канала связи. После того, как процесс будет выполнен, появится окно конфигурации установки. Из предложенных компонентов, нам необходимо выбрать опцию ".Net desktop development": 

Рис. 4. Выбор компонентов

После того, как опция выбрана, необходимо нажать на кнопку Install. Начнется процесс инсталляции, который также займет некоторое время:

Рис. 5. Процесс инсталяции.

После завершения инсталляции Visual Studio запустится автоматически. Если этого не произошло, запустите ее вручную. При первом запуске Visual Studio попросит войти в Ваш аккаунт или создать новый. Если у Вас нет аккаунта, лучше зарегистрировать его сейчас, для чего нажать ссылку "Create One":

После  регистрации и входа в учетную запись, запустится Visual Studio. Давайте попробуем создать нашу первую визуальную форму и подключить ее к MetaTrader. Прочитав этот раздел до конца, Вы убедитесь, как на самом деле просто это сделать.

//+------------------------------------------------------------------+
//|                                              GuiMtController.mq5 |
//|                        Copyright 2019, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
#import  "MtGuiController.dll"
string assembly = "С:\\Users\\Bazil\\source\\repos\\GuiMT\\GuiMT\\bin\\Debug\\GuiMT.exe";
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- create timer
   EventSetMillisecondTimer(200);
   GuiController::ShowForm(assembly, "Form1");
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- destroy timer
   GuiController::HideForm(assembly, "Form1");
   EventKillTimer();   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
//---
}
//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
   for(static int i = 0; i < GuiController::EventsTotal(); i++)
   {
      int id;
      string el_name;
      long lparam;
      double dparam;
      string sparam;
      GuiController::GetEvent(i, el_name, id, lparam, dparam, sparam);
      if(id == ClickOnElement)
         printf("Click on element " + el_name);
   }
  }
//+------------------------------------------------------------------+

string assembly = "С:\\Users\\Bazil\\source\\repos\\GuiMT\\GuiMT\\bin\\Debug\\GuiMT.exe";

Взаимодействия MQL-программы с GuiController, событийна модель

Чтобы понять, как работает сделанная нами программа, давайте разберем подробно предыдущий листинг MQL кода.

Итак, первое что мы видим — это деректива import и строка assembly:

#import  "MtGuiController.dll"
string assembly = "C:\\Users\\Bazil\\source\\repos\\GuiMT\\GuiMT\\bin\\Debug\\GuiMT.exe";

Первая строка говорит компилятору о том, что будет использованы вызовы к открытым статическим методам класса, располагающимся в MtGuiController.dll. Обратите внимание, что указывать к каким именно методам мы будет обращаться в этой сборке не нужно. Эту работу выполнит за нас компилятор в автоматическом режиме.

Вторая строка содержит путь к форме, которой мы будем управлять. Этот адрес должен соответствовать фактическому расположению Вашей формы.

Далее содержится стандартный код процедуры инициализации советника OnInit:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- create timer
   EventSetMillisecondTimer(200);
   GuiController::ShowForm(assembly, "Form1");
//---
   return(INIT_SUCCEEDED);
  }

В ней происходит установка высокочастотного таймера и первый вызов одного из метода нашего класса. Функцию таймера мы опишем чуть позже, а сейчас обратимся собственно к вызову ShowForm:

GuiController::ShowForm(assembly, "Form1");

В C# функции не могут существовать отдельно от классов. Таким образом у каждой функции (метода) есть свой класс, в котором она определена. В MtGuiController.dll определен единственный класс GuiController. Он содержит статические методы, с помощью которых можно управлять тем или иным окном. Других классов в MtGuiController.dll нет, а значит все управление централизовано происходит через этот класс. Это очень удобно, т.к. пользователь работает с одним единственным интерфейсом взаимодействия и не ищет нужную ему функцию из набора разрозненных определений.

Первое что делается в блоке инициализации — это вызов метода ShowForm. Как нетрудно догадаться из его названия, он занимается тем, что запускает процесс отображения формы. Первый параметр метода задает абсолютный путь к файлу, в котором определена форма, а второй задает имя самой формы. Дело в том, что в одном файле может быть опредено сразу несколько форм. Поэтому и необходимо указать какую именно форму в файле мы хотим запустить. Названием формы в данном случае является название класса формы, которое Visual Studio назначила по-умолчанию форме созданной нами. Если открыть наш ранее созданный проект в Visual Studio и открыть файл Form1.Designer.cs в режиме просмотра кода, то мы увидим название класса, которое нам нужно:

partial class Form1
{
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;
        ...
}

В дальнейшем, необходимо будет давать более осмысленные названия классов. В Visual Studio это достаточно легко сделать просто переименовав класс и все упоминания о нем. В этом случае значение второго параметра метода ShowForm придется также поменять.

Следующая функция к которой мы перейдем, это OnTimer. Согласно установки таймера она вызывается пять раз в секунду. Внутри нее содержится наиболее интересный код всего нашего проекта. Тело функции состоит из цикла for, который перебирает порядковые номера событий:

for(static int i = 0; i < GuiController::EventsTotal(); i++)
   {
      int id;
      string el_name;
      long lparam;
      double dparam;
      string sparam;
      GuiController::GetEvent(i, el_name, id, lparam, dparam, sparam);
      if(id == ClickOnElement)
         printf("Click on element " + el_name);
   }

Событие, с точки зрения контроллера, это любое действие пользователя над формой. Например, когда пользователь нажимает на кнопку или вводит текст в текстовое окно, контроллер получает соответствующее событие и помещает его в список событий. Количество событий в списке транслируется статическим методом GuiController::EventsTotal(), который может вызвать наша MQL-программа.

В Windows Forms существует огромное количество событий. Каждый элемент, такой как форма, кнопка, или текстовое окно, содержит несколько десятков событий. Не все события представляется возможным обработать, да и не все они нужны. Поэтому GuiController обрабатывает только самые важные события. В текущей версии обрабатываемых событий всего три. Это следующие события:

• Событие нажатия кнопки;
• Событие окончания вода текста;
• Событие горизонтального скролла.

В дальнейшем этот список планируется расширить, но для целей данной статьи предложенного списка пока достаточно.

Итак, после того как произойдет событие, которое поддерживает наш GuiController, оно будет им обработано и добавлено в список событий. Обработка события заключается в создании данных, получив которые MQL-программа могла бы относительно легко определить тип события и его параметры. Именно поэтому формат данных каждого события имеет очень схожую структуру с событийной моделью функции OnChartEvent. Благодаря этому сходству, пользователю, работающему с GuiController не нужно учить формат новой событийном модели. Конечно, в представленном подходе есть и свои трудности, например, непростые события вроде того же скролла крайне сложно уместить в предложенный формат, но и эти проблемы легко решаемы с помощью языковых средств C# и его развитой объектно-ориентированной модели программирования. Сейчас же предложенной модели будет вполне достаточно для решения наших задач.

Каждый раз при поступлении нового события, его данные становятся доступными для получения через ссылочные типы с помощью статического метода GuiController::GetEvent. Этот метод имеет следующий прототип:

public static void GetEvent(int event_n, ref string el_name, ref int id, ref long lparam, ref double dparam, ref string sparam)

Опишем его параметры по порядку: 

• event-n — порядковый номер события, который необходимо получить. Благодаря возможности указать порядковый номер события становится легко контролировать новые события, в каком бы количестве они не поступали;
• el_name — имя элемента, который сгенерировал данное событие;
• id — Тип события.
• lparam — целочисленное значение, которое имеет данное событие;
• dparam — вещественное значение, которое имеет данное событие;
• sparam — строковое значение, которое имеет данное событие.

Как видите, событийная модель GuiController сильно напоминает событийную модель OnChartEvent. Любое событие в GuiController всегда имеет порядковый номер и источник (имя элемента), которое это событие сгенерировал. Остальные параметры являются опциональными. Так некоторые события, вроде нажатия кнопки, вообще не имеют дополнительных параметров (lparam, dparam, sparam), другие же их содержат. Например событие окончание текста в параметре sparam содержит текст, который был введен в поле пользователем.

Ниже приведена таблица, которая содержит события и их параметры, подерживаемые на текущий момент:

Название события	Идентификатор (id)	Параметры
Exception	0	sparam - содержит сообщение, вызвавшего исключения
ClickOnElement	1	-
TextChange	2	sparam - новый текст, введенный пользователем
ScrollChange	3	lparam - предыдущий уровень скролла dparam - текущий уровень скролла

Теперь, когда мы разобрались с событийной моделью в GuiController, мы можем понять код, представленный внутри цикла for. Строка:

GuiController::GetEvent(i, el_name, id, lparam, dparam, sparam);

Получает событие по индексу i. Если тип события соответствует нажатию кнопки, то в консоль терминала выводится название кнопки и сообщение о ее нажатии:

if(id == ClickOnElement)
   printf("Click on element " + el_name);

Обратите внимание, что id сравнивается с константой ClickOnElement, которая нигде в MQL-коде программы не определена. Действительно, данная константа является частью перечисления определенного в самом GuiController на C#^

/// <summary>
/// Type of gui event
/// </summary>
public enum GuiEventType
{
    Exception,
    ClickOnElement,
    TextChange,
    ScrollChange
}

Как видите, компилятор понимает внешние перечисления определенные в Net-библиотеках и умеет с ними работать. 

Обратим еще раз внимание на то, как происходит получение сообщений. Для этих целей используется таймер. Хотя в действительности может использоваться любая другая функция, вызывающаяся периодически, например OnTick. Однако периодичности очень трудно контролировать. Нельзя наверняка сказать сколько времени будет происходить между двумя последовательными вызовами OnTick.

Более того, нельзя определенно гарантировать периодичность вызова даже OnTimer. Например в тестере стратегий предельная частота вызова OnTimer сильно отличается от той, что можно выставить этой функции в режиме реальной работы. Все эти эффекты приводят к тому, что между двумя вызовами функций пользователем может быть сгенерировано несколько событий подряд. Например, он может нажать кнопку дважды или трижды, прежде чем MQL-программа успеет отреагировать на первое нажатие.

Именно для этих целей организована очередь событий. Каждое событие поступает в список, а затем ждет, когда его параметры будут извлечены MQL-программой. Сама же программа запоминает последний номер события с помощью определения статической переменной в функции, и при следующем запуске получает поступившие вновь события! Именно поэтому цикл for имеет нестандартную сигнатуру:

//-- Цикл запоминает последний индекс события и при следующем запуске функции начинает работать с него
for(static int i = 0; i < GuiController::EventsTotal(); i++)

События можно как получать с помощью метода GuiController::GetEvent, так и отправлять их с помощью GuiController::SendEvent. Второй метод используется, кода нужно отправить какие-нибудь данные в окно и изменить его содержимое. Он имеет тот же прототип, что и GetEvent, единственная разница, что он не содержит порядковый номер события, так как в этом случае такой номер бессмысленен. Мы не будет останавливаться на нем подробно, однако покажем работу с ним на примере, который будет представлен в заключительной части статьи.

Последний метод, который мы не разобрали, это GuiController::HideForm. Его сигнатура аналогична ShowForm, а действие зеркально противоположное: данный метод скрывает окно, для чего необходимо указать его расположение и имя.

Как видите, код на MQL, который занимается отображением формы и анализом поступающих от ней событий, получился очень компактным и простым. По сути код описывает три простых действия:

1. Отобразить окно при запуске программы;
2. Получать новые события от окна;
3. Скрыть окно при выходе из программы;

Более простую схему сложно было бы придумать. Обратите внимание также на сам код формы, которую мы создали. Хотя форма окна содержит этот самый код, сами мы не написали ни строчки на C#. Всю работу за нас сделали развитые средства автогенерации кода в Visual Studio и собственно GuiController. Именно так проявляется мощь технологий Net, ведь конечной цель мощных сред как раз и является простота.

Под капотом у GuiController

Если Вы недостаточно хорошо разбираетесь в C#, данный раздел Вы можете смело пропустить. Он будет интересен тем, кто хочет разобраться как устроен GuiController и как происходит доступ к отдельным, изолированным приложениям Net.

GuiController представляет из себя разделяемый класс, состоящий из двух частей: статической и части экземпляра. В статической части класса сосредоточены открытые статические методы для взаимодействия с MetaTrader. Эта часть класса реализует интерфейс между MetaTrader 5 и самим контроллером. Вторая часть экземплярная — это значит, что данные и методы этой части существуют только на уровне экземпляра. В их задачу входит взаимодействие с независимыми сборками Net, в которых располагаются графические окна. Само графическое окно в Windows Forms — это класс, унаследованный от базового класса Form. Таким образом, с каждым пользовательским окном можно работать на более высоком и абстрактном уровне класса Form.

Внутри сборок Net, таких как DLL или EXE, содержатся типы Net, которые являются открытыми по своей сути. Получить доступ к ним, их свойствам и даже методам довольно просто. Это можно сделать с помощью механизма, называемого в Net  рефлексией или отражением. Благодаря этому механизму, каждый файл вроде DLL или EXE, созданный в Net, можно исследовать на предмет наличия нужного нам элемента. Именно этим и занимается класс GuiController. Когда в его метод ShowForm передают абсолютный путь к сборке в Net, то контроллер загружает эту сборку с помощью специального механизма, после чего находит в ней графическое окно, которое необходимо отобразить. Приведем код метода GetGuiController, который выполняет эту работу:

/// <summary>
/// Create GuiController for windows form
/// </summary>
/// <param name="assembly_path">Path to assembly</param>
/// <param name="form_name">Windows Form's name</param>
/// <returns></returns>
private static GuiController GetGuiController(string assembly_path, string form_name)
{
    //-- Загрузить указанную сборку
    Assembly assembly = Assembly.LoadFile(assembly_path);
    //-- Найти в ней указанную форму
    Form form = FindForm(assembly, form_name);
    //-- Назначить найденной форме управляющий контроллер
    GuiController controller = new GuiController(assembly, form, m_global_events);
    //-- Вернуть управляющий контроллер вызывающему методу
    return controller;
}

Данная процедура напоминает так называемый граббер ресурсов: специальную программу, с помощью которой можно извлечь медиа-контент вроде иконок и изображений из двоичного кода программы.

Поиск формы осуществляется с помощью рефлексии. Метод FindForm получает все типы, определенные в переданной ему сборке. Среди этих типов он ищет те, чей базовый тип соответствует типу Form. Если название такого найденного типа также соответствует нужному, то создается экземпляр этого типа, который и возвращается в виде формы:

/// <summary>
/// Find needed form
/// </summary>
/// <param name="assembly">Assembly</param>
/// <returns></returns>
private static Form FindForm(Assembly assembly, string form_name)
{
    Type[] types = assembly.GetTypes();
    foreach (Type type in types)
    {
        //assembly.CreateInstance()
        if (type.BaseType == typeof(Form) && type.Name == form_name)
        {
            object obj_form = type.Assembly.CreateInstance(type.FullName);
            return (Form)obj_form;
        }
    }
    throw new Exception("Form with name " + form_name + " in assembly " + assembly.FullName + "  not find");
}

Наиболее захватывающим моментом является создание самого приложения и его запуск. Ведь по сути из внешнего набора бинарных данных "оживает" настоящая программа, которая начинает работать как независимая программа.

После того как экземпляр создан, ему назначается контроллер. Контроллер — это экземплярная часть класса GuiController, которая следит за переданной ей формой. В обязанности контроллера входит отслеживать и передавать события для формы.

Запуск формы и ее удаление осуществляются в параллельном потоке. Благодаря этому текущий поток не блокируется в ожидании завершения текущей операции. Представим, что мы запустили окно в  текущем потоке. Так как окно продолжает работать, то вызвавший его внешний процесс зависает в ожидании закрытия окна. Запуск окна в отдельном потоке решает эту проблему.

За запуск и удаление окна отвечают соответствующие методы контроллера:

/// <summary>
/// Пользовательскую форму, вызванную из MetaTrader необходимо запускать в асинхронном режиме,
/// что бы обеспечить отзывчивость интерфейса.
/// </summary>
public static void ShowForm(string assembly_path, string form_name)
{
    try
    {
        GuiController controller = GetGuiController(assembly_path, form_name);
        string full_path = assembly_path + "/" + form_name;
        m_controllers.Add(full_path, controller);
        controller.RunForm();
    }
    catch(Exception e)
    {
        SendExceptionEvent(e);
    }
}
        
/// <summary>
/// После того, как эксперт закончит работу с формой, необходимо завершить процесс ее выполнения.
/// </summary>
public static void HideForm(string assembly_path, string form_name)
{
    try
    {
        string full_path = assembly_path + "/" + form_name;
        if (!m_controllers.ContainsKey(full_path))
            return;
        GuiController controller = m_controllers[full_path];
        controller.DisposeForm();
    }
    catch(Exception ex)
    {
        SendExceptionEvent(ex);
    }
}

Последнее, что нам необходимо рассмотреть из работы контроллера — это работа с событиями. Когда с помощью рефлексии создается новая форма, то она передается методу, который подписывается на ее события — вернее, только на те из них что может обработать контроллер. Для этих целей создается сопоставление <элемент - список обработчиков событий>, где каждый обработчик событий подписан на нужное ему событие: 

/// <summary>
/// Subscribe on supported events
/// </summary>
/// <param name="form">Windows form</param>
private void SubscribeOnElements(Form form)
{
    Dictionary<Type, List<HandlerControl>> types_and_events = new Dictionary<Type, List<HandlerControl>>();
    types_and_events.Add(typeof(VScrollBar), new List<HandlerControl>() { vscrol => ((VScrollBar)vscrol).Scroll += OnScroll });
    types_and_events.Add(typeof(Button), new List<HandlerControl>()  { button => ((Button)button).Click += OnClick });
    types_and_events.Add(typeof(Label), new List<HandlerControl>());
    types_and_events.Add(typeof(TextBox), new List<HandlerControl>() { text_box => text_box.LostFocus += OnLostFocus, text_box => text_box.KeyDown += OnKeyDown });
    foreach (Control control in form.Controls)
    {
        if (types_and_events.ContainsKey(control.GetType()))
        {
            types_and_events[control.GetType()].ForEach(el => el.Invoke(control));
            m_controls.Add(control.Name, control);
        }
    }
}

Каждая форма имеет открытый список элементов, которая она содержит. Перебирая список элементов, метод находит те из них, что контроллер способен поддержать, и подписывается на нужные ему события. Если элемент на форме не поддерживается контроллером, то он просто будет проигнорирован. События, связанные с ним, не будут доставлены в MQL-программу, а сама MQL-программа не сможет взаимодействовать с этим элементом.

Торговая панель на основе графических интерфейсов

Теперь, когда мы рассмотрели все части нашей системы, настала пора создать что-то действительно полезное. Мы сделаем аналог стандартной торговой панели, которая содержится в верхнем левом углу чарта:

Рис. 15. Встроенная торговая панель MetaTrader 5.

Конечно, наша панель будет состоять из стандартных графических элементов окна Windows, поэтому будет иметь более простой дизайн, однако функционал, заложенный в ней будет идентичный.

Можно поступить по-разному, например, начать создавать такую панель с чистого нуля. Однако описывать работу визуального конструктора будет излишним в этой статье. Поэтому мы поступим проще и загрузим проект, содержащий эту панель в Visual Studio. Сделать это можно двумя способами: либо скопировать проект из архива и открыть его в Visual Studio, либо скачать его из удаленного репозитория Git по следующему адресу: 

Работа с git в этом случае будет такой же, как описывалась в соответствующем разделе, поэтому не будем повторяться.

После того, как проект будет загружен и открыт, Вы должны будете увидеть следующую форму:

Рис. 16. Окно TradePanel в визуальном конструкторе Visual Studio

Проект содержит макет торговой панели. В реальных проектах вроде этого нам потребуется постоянно получать доступ к элементам, размещенным на этой форме, а также отправлять им события. Для этих целей будет необходимо обращаться к каждому элементу по его имени. Поэтому имена элементов должны быть осмысленными и запоминающимися. Давайте посмотрим как называются элементы, которые мы будем использовать. Чтобы посмотреть имя каждого элемента нужно найти свойство Name в окне Properties, предварительно выделив этот элемент. Так например кнопка с надписью Buy будет обладать именем ButtonBuy:

Рис. 17. Имя элемента в окне Properties.

Хотя элементов, которые мы используем, совсем немного, комбинируя их, мы получаем довольно продвинутый интерфейс. Заметим, что как и в предыдущем примере, наше решение не содержит ни одной строки кода на C# которую пришлось бы добавлять. Все нужные свойства элементов выставлены в окне Properties, а расположение и размер элементов установлены с помощью drag-n-drop техники, т.е. с помощью мышки!

Интеграция графического окна с кодом эксперта

Теперь, когда наше окно готово, его необходимо интегрировать с торговым экспертом. Мы напишем торговую логику на языке программирования MQL, которая будет взаимодействовать с элементами нашего интерфейса. Полный код эксперта представлен ниже:

//+------------------------------------------------------------------+
//|                                                   TradePanel.mq5 |
//|                        Copyright 2019, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
#import  "MtGuiController.dll"
#include <Trade\Trade.mqh>
string assembly = "c:\\Users\\Bazil\\source\\repos\\TradePanel\\TradePanel\\bin\\Debug\\TradePanel.dll";
string FormName = "TradePanelForm";
double current_volume = 0.0;

//-- Trade module for executing orders
CTrade Trade;  
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
//--- create timer, show window and set volume
   EventSetMillisecondTimer(200);
   GuiController::ShowForm(assembly, FormName);
   current_volume = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN);
   GuiController::SendEvent("CurrentVolume", TextChange, 0, 0.0, DoubleToString(current_volume, 2));
//---
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Dispose form
   EventKillTimer();
   GuiController::HideForm(assembly, FormName);
//---
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
//--- refresh ask/bid   
   double ask = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
   double bid = SymbolInfoDouble(Symbol(), SYMBOL_BID);
   GuiController::SendEvent("AskLabel", TextChange, 0, 0.0, DoubleToString(ask, Digits()));
   GuiController::SendEvent("BidLabel", TextChange, 0, 0.0, DoubleToString(bid, Digits()));
//---
}

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
{
//--- get new events by timer
   for(static int i = 0; i < GuiController::EventsTotal(); i++)
   {
      int id;
      string el_name;
      long lparam;
      double dparam;
      string sparam;
      GuiController::GetEvent(i, el_name, id, lparam, dparam, sparam);
      if(id == TextChange && el_name == "CurrentVolume")
         TrySetNewVolume(sparam);
      else if(id == ScrollChange && el_name == "IncrementVol")
         OnIncrementVolume(lparam, dparam, sparam);
      else if(id == ClickOnElement)
         TryTradeOnClick(el_name);
   }
//---
}
//+------------------------------------------------------------------+
//| Validate volume                                                  |
//+------------------------------------------------------------------+
double ValidateVolume(double n_vol)
{
   double min_vol = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN);
   double max_vol = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX);
   //-- check min limit 
   if(n_vol < min_vol)
      return min_vol;
   //-- check max limit
   if(n_vol > max_vol)
      return max_vol;
   //-- normalize volume
   double vol_step = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
   double steps = MathRound(n_vol / vol_step);
   double corr_vol = NormalizeDouble(vol_step * steps, 2);
   return corr_vol;
}
//+------------------------------------------------------------------+
//| Set new current volume from a given text                         |
//+------------------------------------------------------------------+
bool TrySetNewVolume(string nstr_vol)
{
   double n_vol = StringToDouble(nstr_vol);
   current_volume = ValidateVolume(n_vol);
   string corr_vol = DoubleToString(current_volume, 2);
   GuiController::SendEvent("CurrentVolume", TextChange, 0, 0.0, corr_vol);
   return true;
}
//+------------------------------------------------------------------+
//| Execute trade orders                                             |
//+------------------------------------------------------------------+
bool TryTradeOnClick(string el_name)
{
   if(el_name == "ButtonBuy")
      return Trade.Buy(current_volume);
   if(el_name == "ButtonSell")
      return Trade.Sell(current_volume);
   return false;
}
//+------------------------------------------------------------------+
//| Increment or decrement current volume                            |
//+------------------------------------------------------------------+
void OnIncrementVolume(long lparam, double dparam, string sparam)
{
   double vol_step = 0.0;
   //-- detect increment press
   if(dparam > lparam)
      vol_step = (-1.0) * SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
   //-- detect decrement press
   else if(dparam < lparam)
      vol_step = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
   //-- detect increment press again
   else if(lparam == 0)
      vol_step = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
   //-- detect decrement press again
   else
      vol_step = (-1.0) * SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
   double n_vol = current_volume + vol_step;
   current_volume = ValidateVolume(n_vol);
   string nstr_vol = DoubleToString(current_volume, 2);
   GuiController::SendEvent("CurrentVolume", TextChange, 0, 0.0, nstr_vol);
}
//+------------------------------------------------------------------+

Представленный код выполняет основную рабочую нагрузку нашей формы. Однако примечательно, что весь этот функционал написан именно на MQL5, внутри стандартных функций-обработчиков событий. Давайте более подробно проанализируем представленный код.

Первое, что делается в функции OnInit — это устанавливается таймер с разрешением 200 миллисекунд. Затем отображается окно с помощью метода ShowForm:

GuiController::ShowForm(assembly, FormName);

где assembly — путь к сборке, в которой находится наше окно, а FormName — имя класса нашей формы.

Сразу после того, как окно запущено, мы устанавливаем минимальный объем в текстовое поле "CurrentVolume":

GuiController::SendEvent("CurrentVolume", TextChange, 0, 0.0, DoubleToString(current_volume, 2));

Сам минимальный объем рассчитывается исходя из текущего торгового окружения, с помощью функции SymbolInfoDouble.

При закрытии советника, окно формы закрывается. Делается это в функции OnDeinit, с помощью метода GuiController::HideForm; 

Функция OnTick реагирует на изменение текущей цены Ask/Bid. Таким образом, если получать текущие цены в этой функции и передавать их в соответствующие текстовые метки формы, панель будет оперативно отображать все изменения текущей цены.

//-- Получить цену Ask
double ask = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
//-- Получить цену Bid
double bid = SymbolInfoDouble(Symbol(), SYMBOL_BID);
//-- Изменить текст в текстовой метке AskLabel на текущую цену Ask переведенную в строку:
GuiController::SendEvent("AskLabel", TextChange, 0, 0.0, DoubleToString(ask, Digits()));
//-- Изменить текст в текстовой метке BidLabel на текущую цену Bid переведенную в строку:
GuiController::SendEvent("BidLabel", TextChange, 0, 0.0, DoubleToString(bid, Digits()));

В функции OnTimer происходит отслеживания трех действий, который пользователь может выполнить с формой, а именно:

• Ввести новый объем в текстовую метку CurrentVolume;
• Нажать на кнопку увеличения или уменьшения шага объема выполненную в виде скролла;
• Нажать на кнопку Buy или Sell, тем самым отправляя приказ на совершения сделки.

В зависимости от того, какое действие было выполнено пользователем, будет происходить определенный набор инструкций. Событие нажатие кнопок скролла, которые должны увеличивать или уменьшать текущий объем на минимально-допустимый шаг, мы еще не анализировали, поэтому давайте остановимся на нем более подробно.

Событие скролла в текущей событийной модели состоит из двух параметров lparam и dparam. Первый параметр содержит условную величину, которая характеризует сдвиг каретки относительно нулевого уровня до нажатия кнопок скролла пользователем. Второй параметр содержит эту же величину, но уже после нажатия. Сам скролл имеет определенный диапазон работы, например от 0 до 100. Так если значение lparam равно 30, а значение dparam равно 50, то это значит, что вертикальный скролл был передвинут вниз с 30 до 50% (горизонтальный скролл соответственно передвинется не вниз, а вправо на аналогичную величину). В нашей панели определять где именно находится скролл не требуется. Нам необходимо лишь знать по какой кнопке нажал пользователь. Для этого нужно проанализировать предыдущее и текущее значение. Именно этим и занимается функция OnIncrementVolume. Определив тип нажатия скролла, она увеличивает или уменьшает текущий объем на минимальный шаг объема, который узнает с помощью системной функции SystemInfoDouble.

Устанавливать новый торговый объем можно не только с помощью стрелок скролла. Также его можно вводить в текстовую метку напрямую. Когда пользователь вводит новый символ, windows forms генерирует соответствующее событие. Однако нам важно проанализировать конечную строку, а не каждый символ по отдельности. Поэтому GuiController реагирует на нажатие клавиши 'Enter' или на смену фокуса текстовой метки. Именно эти события считаются окончанием ввода текста. Когда происходит одно из них, сформированный текст передается в очередь событий, которую последовательно читает наш эксперт. Добравшись до события изменения текста в метке, MQL-программа разбирает его новое значение и устанавливает новый объем согласно заданному. Анализ осуществляется с помощью функции ValidateVolume. Она контролирует следующие параметры введенного объема:

• Объем должен быть между минимально и максимально допустимым;
• Величина объема должна быть кратна его шагу. Так если шаг 0.01 лота, а пользователь введет цифру 1.0234, то она будет скорректирована до 1.02;

Заметим, что данные параметры возможно проконтролировать только с помощью текущего торгового окружения. Таким образом, весь контроль вводимых пользователем значений осуществляется самой MQL-программой, а не созданной пользователем формой. 

Давайте запустим торговую панель на графике и попробуем совершить несколько сделок с ее помощью:

Рис. 18. Работа панели в режиме реального времени. 

Как видите, торговая панель работает и отлично выполняет возложенные на нее функции.

Работа графических интерфейсов в тестере стратегий

Тестер стратегий в MetaTrader 5 имеет ряд особенностей, которые должен учитывать разработчик графических интерфейсов на языке программирования MQL. Главной особенностью является тот факт, что функция обработки графических событий OnChartEvent не вызывается вовсе. Эта особенность логична, т.к. графическая форма подразумевает работу с пользователем в режиме реального времени. Однако есть тип панелей, который было бы крайне интересно реализовать именно в тестере. Это так называемые торговые плееры, с помощью которых люди могли бы тестировать свои торговые стратегии в ручном режиме. Например, тестер стратегий в ускоренном режиме генерировал текущие рыночные цены, а пользователь нажимал бы на кнопки купить или продать и тем самым симулировал свои торговые действия на истории. Именно к такому типу панелей можно отнести созданную нами TradePanel. Не смотря на свою простоту, она вполне может быть простым плеером торговли с самым необходимым функционалом. 

Но давайте подумаем, как наша панель будет работать в тестере стратегий MetaTrader 5. Графическое окно панели TradePanel существует в виде независимой сборки Net. Следовательно оно никак не зависит от текущего окружения MetaTrader 5 и даже самого терминала. Строго говоря, его можно запустить из любой другой программы, а сборки размещенные в exe-контейнере может запустить даже сам пользователь.

Таким образом, нашей программе не требуется вызов OnChartEvent. Более того, обновлять данные в окне и получать новые приказы от пользователей можно в любой функции-обработчике событий, которая регулярно запускается в тестере стратегий. К таким функциям относятся OnTick и OnTimer. Именно через них и работает наша панель. Следовательно, разработанная для работы в режиме реального времени, наша панель будет также хорошо работать и в тестере стратегий. Делать какие-либо изменения для этого не потребуется. Давайте проверим данное утверждение, запустив нашу панель в тестере и совершим несколько сделок в ней:

Рис. 19. Работа панели в режиме симуляции, в тестере стратегий.

Получается что разработка графических интерфейсов с помощью C# дает нам неожиданный бонус при работе в тестере стратегий. Для приложения Windows Forms тестер стратегий не накладывает никаких ограничений. Особенности работы событийной модели в нем не затрагивают ни панели ни способы работы с ними. Переделывать программу под работу в тестере стратегий также не нужно. 

Заключение