Проект приложения с графическим интерфейсом windows c

В интернете можно обнаружить множество роликов, насколько легко было создавать графические приложения в Visual Studio 2010 через «Windows Forms Application». В VS2015 и VS2017 с инструментами для новичков стало сложнее. Создать приложение можно несколькими способами, наиболее простым является через «CLR Empty Project». Статья предназначена для новичков, но предполагает, что читатель уже не испытывает проблем с созданием консольных приложений вида «Hello World». Бесплатную VS Community 2017 можнос скачать с visualstudio.com.

1. В первую очередь перечислим, какие компоненты должны быть установлены для создания графического приложения на языке С++. Их три, все относятся к разделу «Desktop development with C++»:
— VC++ 2017 v141 toolset (x86,x64)
— Windows 10 SDK (10.0.15063.0) for Desktop C++ x86 and x64
— C++/CLI support

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

2. После установки среды разработки переходим
File > New > Project… (^+N)
В появившемся окне отыскиваем Installed > Visual C++ > CLR > CLR Empty Project

Поля внизу заполняем традиционным для таких программ способом. В названии проекта лучше не допускать пробелов, иначе вам потом придётся мудрить в коде.

3. Необходимо добавить в приложение главную форму. Есть два равносильных пути достижения этой цели.
Первый: в «Solution Explorer» правой кнопкой мыши на названии проекта, во всплывшем контексном меню Add > New Item…
Второй способ: в главном меню выбираем Project > Add New Item…
Или просто нажимаем ^+A
   

Во появившемся окне Visual C++ > UI > Windows Form

Главная форма программы создана. На некоторых компьютерах в данный момент возможно выскакивание ошибки 0x8000000A, в этом случае нужно просто закрыть вкладку.

Эта ошибка хорошо известна ещё по Visual Studio 2015. Можете почитать её обсуждение, к примеру, на сайте Microsoft по ссылке1, ссылке2, ссылке3. И более лучшего решения, чем закрывать вкладку, ещё нет. По всей видимости, команда разработчиков Visual Studio не считает эту ошибку достаточно серьёзным делом, чтобы ломать о неё копья.

4. Но мало просто создать форму, нужно вплести её в создаваемую программу. Для этого в «Solution Explorer» правой кнопкой мыши на названии проекта, во всплывшем контексном меню выбрать Properties.

В открывшемся окне произвести два действия.
• Linker > System > SubSystem, из раскрывающегося списка выбрать «Windows (/SUBSYSTEM:WINDOWS)«

• Linker > Advanced > Entry Point. В пустое поле вписать «main» (без кавычек).

5. В «Solution Explorer» двойным щелчком открыть в редакторе файл MyForm.cpp. Скопировать в него текст

#include «MyForm.h»
using namespace System;
using namespace System::Windows::Forms;
[STAThread]
void main(array<String^>^ args) {
    Application::EnableVisualStyles();
    Application::SetCompatibleTextRenderingDefault(false);
    Project1::MyForm form;
    Application::Run(%form);
}

Заменив Project1 на название вашего проекта. (Теперь понятно, почему ранее мною не рекомендовалось использовать в названии проекта пробелы?)

Отлично, всё готово! Теперь проект компилируем и запускаем. Но если у вас ранее выскакивала 0x8000000A, то быстрее всего вам придётся перезапустить Visual Studio и вновь загрузить в нём проект. Далее ошибка ни в чём не проявится.

6. Для того, чтобы добавить на нашу только что созданную форму новые элементы, понадобится панель Toolbox. Полезно запомнить горячую клавишу ^!X

Работа с размещением элементов на форме сложностей вызвать не должна. Работает здесь всё удобнее, чем wxWidgets в CodeBlocks или wxDev-C++. Никаких глюков мною замечено не было.

Для изменения свойств только что созданного элемента интерфейса щёлкните на нём правой кнопкой и в контекстном меню выберите, соответственно, Properties.

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

    MessageBox::Show(«Hello World»,
        «My heading», MessageBoxButtons::OKCancel,
        MessageBoxIcon::Asterisk);

Запускаем и проверяем!

Если вдруг не запустится, то первым делом проверяем, что выставлено в раскрывающемся списке Solution Configurations. Он находится на панели инструментов (под главным меню). Там должно быть Release (а не Debug).

Дополнительная информация

Альтернативные способы создания графических приложений в Visual Studio 2017.

1. UWP (Universal Windows Platfrom application) — универсальные приложения, способные запускаться на Windows 10, Windows 10 Mobile и аналогичных самых современных платформах от Microsoft. Платформа разработана как расширение Windows Runtime. Всё бы хорошо, но данные приложения не могут запускаться на более старых версиях Windows, даже на восьмёрке.

2. Windows Desktop Application — примерно то же самое, что в более VS2015 называлось «Win32 Project», а в VS2010 «Windows Forms Application». Технология, которую сейчас можно уже называть устаревшей. В VS2010 это был простой и удобный способ создания графических программ. Но затем ребята из Microsoft решили перетаскивать начинающих разработчиков на более современные технологии. При использовании данного инструмента в VS2015 и в VS2017 приложение создаётся, его можно запустить и посмотреть. Но у этого приложения нет готовой главной формы, куда можно было перетаскивать кнопки и прочие компоненты. Мне не удалось обнаружить в сети ни одного источника, где бы рассказывалось о лёгком способе её создать. Только через длинный код, для получения представления о процессе можете посмотреть видео на msdn.microsoft.com и прочитать соответствующее описание.

Пара слов для общего развития о нескольких технологиях, на которые вы будете постоянно натыкаться при чтении документации по разработке GUI в Visual Studio.

ATL (Active Template Library) — набор шаблонных классов языка C++, предназначенных для упрощения написания COM-компонентов.
MFC (Microsoft Foundation Classes) — библиотека объектов, помогающая профессиональным разработчикам создавать десктопные приложения. Что-то вроде более усложнённого и навороченного варианта ATL. ATL и MFC являются хорошими вещами, и с их задействованием также можно создавать графические приложения. Но это инструменты, требующие наличия углублённых знаний тематики.

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

Примечания:
В интернете можно наткнуться на заголовок «Full C and C++ IDE with Visual Studio».  Оттуда закачиваются те же самые стандартные дистрибутивы Visual Studio, проверено по контрольным суммам.

«Visual C++ 2017 Build Tools» — это комплект различных Windows SDK и .NET Framework. MFC, ATL и CLI support и ещё пара подобных штук. Все эти инструменты присутствуют и в стандартном загрузчике VS2017.

P.S.
Теперь можно немного поэкспериментировать с элементами интерфейса. Ниже показан код простейшего графического калькулятора:

А теперь можно попытаться сотворить что-то более похожее на стандартное window-приложение. Пока простейшее.

Первое приложение с .NET CLI

Последнее обновление: 11.11.2022

Для создания графических интерфейсов с помощью платформы .NET применяются разные технологии — Window Forms, WPF, UWP.
Однако наиболее простой и удобной платформой до сих пор остается Window Forms или сокращенно WinForms. Данное руководство ставит своей целью дать понимание принципов создания графических интерфейсов с помощью технологии WinForms
и работы основных элементов управления.

Создадим первое приложение на C# и Windows Forms. Что нам для этого потребуется? Прежде всего необходим текстовый редактор для написания кода программы.
Можно взять любой понравившийся текстовый редактор, например, Visual Studio Code

Также для компиляции и запуска программы нам потребуется .NET SDK. Для его установки перейдем на официальный сайт по ссылке
.NET SDK

После установки .NET SDK для первого проекта определим какую-нибудь папку. Например, в моем случае это будет папка C:dotnetwinformshelloapp.
Откроем терминал/командную строку и перейдем к созданной папке проекта с помощью команды cd

cd C:dotnetwinformshelloapp

В данном случае мы для создания и запуска проекта мы будем использовать встроенную инфраструктуру .NET CLI, которая устанавливается вместе с .NET SDK.

Для создания проекта в .NET CLI применяется команда dotnet new, после которой указывается тип проWindows Formsекта. Для создания проекта
Windows Forms применяется шаблон — winforms. Поэтому введем в терминале команду

После выполнения этой команды у нас будет создан следующий проект:

Структура проекта Windows Forms

Рассмотрим базовую структуру простейшего стандартного проекта Windows Forms:

• helloapp.csproj: стандартный файл проекта C#, который соответствует назанию проекта (по умолчанию названию каталога) и описывает все его настройки.

• helloapp.csproj.user: дополнительный файл проекта C#, который хранит специфичные для текущего пользователя настройки.

• Form1.cs: содержит класс формы, которая по умолчанию запускается при старте приложения

• Form1.Designer.cs: он содержит определение компонентов формы, добавленных
  на форму в графическом дизайнере (графический дизайнер Windows Forms на данный момент официально доступен только в Visual Studio)

• Program.cs: определяет класс Program, который запускается при старте приложения и запускает форму Form1

Например, посмотрим на содержимое файла helloapp.csproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net7.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <UseWindowsForms>true</UseWindowsForms>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

</Project>

Для компиляции приложения Windows Forms указаны следующие настройки:

• OutputType: определяет выходной тип проекта. Должен иметь значение WinExe — то есть выполняемое приложение с
  расширением exe под Windows

• TargetFramework: определяет применяемую для компиляции версию фреймворка .NET. Поскольку при создании проекта
  была выбрана версия .NET 7, а сам проект зависит от компонентов Windows, то здесь должно быть значение net7.0-windows

• Nullable: подключает в проект функционалность ссылочных nullable-типов

• UseWindowsForms: указывает, будет ли проект использовать Windows Forms (для этого устанавливается значение true)

• ImplicitUsings: подключает в проект функциональность неявно подключаемых глобальных пространств имен

Запуск проекта

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

При запуске запускается графическая форма, код которой определяет класс Form1:

Запуск приложения

Файл Program.cs определяет точку входа в приложение:

namespace helloapp;

static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        Application.Run(new Form1());
    }    
}

Метод Main снабжен атрибутом [STAThread]. Этот атрибут, грубого говоря,
необходим для корректной работы компонентов Windows. В самом методе сначала вызывается метод

ApplicationConfiguration.Initialize()

который устанавливает некоторую базовую конфигурацию приложения

Затем вызывается метод

Application.Run(new Form1());

в который передается объект отображаемой по умолчанию на экране формы.

То есть, когда мы запустим приложение, сработает метод Main, в котором будет вызван метод Application.Run(new Form1()),
благодаря чему мы увидим форму Form1 на экране.

Определение формы

Теперь посмотрим на определение формы и немного изменим его. Для этого откроем файл Form1.cs в текстовом редакторе. По умолчанию он выглядит следующим образом:

namespace helloapp;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
}

Класс формы — Form1 представляет графическую форму — фактически то окно, которое мы увидим на экране при запуске проекта.

Этот класс определяется как частичный (с модификатором partial) и наследуется от встроенного класса Form,
который содержит базовую функциональность форм.

В самом классе Form1 определен по умолчанию только конструктор, где вызывается метод InitializeComponent(), который выполняет инициализацию компонентов формы из файла дизайнера
Form1.Designer.cs. По сути именно код этого файла передается выше через вызов InitializeComponent()

Теперь изменим его код следующим образом:

namespace helloapp;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        // определяем кнопку
        Button button = new Button();
        // текст кнопки
        button.Text ="Click";
        // положение кнопки
        button.Location = new Point(50, 50);
        // размер кнопки
        button.Size = new Size { Width = 80, Height = 30 };
        // обработчик нажатия кнопки
        button.Click += (o, e) => MessageBox.Show("Hello METANIT.COM!");
        // добавление кнопки на форму
        this.Controls.Add(button);
    }
}

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

Создание первого приложения с графическим интерфейсом

Доброго времени суток! В этом уроке мы создадим Ваше первое приложение с графическим интерфейсом в MS Visual Studio. Это будет своего рода «Hello World» для графических приложений. Скажу сразу, что использование Windows Forms — не единственный способ создания графических приложений (приложения с графическим интерфейсом пользователя) для C# программистов, но начать изучение лучше именно с этого. И так, запускаем Visual Studio.

Запустили? Тогда к делу! Идем в главное меню и выбираем пункт «Файл — Создать — Проект», как показано на рисунке ниже.

В появившемся окне:

• в левой части выбираем «Шаблоны — Visual C# — Windows»;
• в основной области выбираем элемент «Приложение Windows Forms»;
• в нижней части окна вводим имя проекта и указываем его расположение на диске.

В общем, как показано на рисунке ниже.

Указали что нужно? Тогда нажимайте на кнопку «OK». Теперь вы должны увидеть примерно следующее (основные области выделены прямоугольниками):

На рисунке выше, я обозначил основные области: область дизайнера (слева вверху), область обозревателя решений (справа вверху) и область свойств (справа внизу). С этими областями, мы будем работать чаще всего.

В области дизайнера, сейчас располагается пустая «форма», это так называемое окно, в данном случае, главное окно нашей программы. В области свойств, отображаются свойства выделенного в дизайнере элемента, в данном случае, нашей формы, ну а область обозревателя решений, содержит файлы проекта, в том числи, относящиеся и к формам (окнам) программы. А теперь, давайте немного изменим нашу форму, и запустим это первое приложение.

Для этого, выделим в дизайнере форму (для этого, можно просто кликнуть левой кнопкой мыши по форме) и перейдем в блок свойств, в котором найдем строку «Text» (слово текст, ищем в левом столбце), как показано на рисунке ниже.

Обратите внимание, в левом столбце указано имя (название свойства), а в правом — его значение.

В данном случае, мы имеем дело с текстовым свойством, и его значение, отображается в заголовке окна, так что, давайте теперь укажем там что-то свое, например, что-то вроде: «Главное окно», как показано на рисунке ниже:

Теперь, можно собрать проект и запустить. Для этого идем в главное меню и выбираем пункт «Сборка — Собрать решение». А потом запускаем приложение, для этого выбираем пункт «Отладка — Запуск без отладки» в главном меню. В результате Вы должны увидеть окно следующее окно.

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

Перейти к следующему уроку

I strongly advise against using plain Win32 because it’s pretty hard to make it work OK in all situations, it’s pretty dull and tedious work and the Common Controls library isn’t that complete. Also, most of the work has been done for you.

Every time I end up doing plain Win32 I have to spent at least a couple of hours on the most trivial tasks because I have to look up all the parameters, flags, functions, macros and figure out how to hook them up properly. I’d generally prefer a simple drag-and-drop don’t-make-me-use-my-brains type of solution and just slam the thing together in 2 minutes.

As a lightweight toolkit I’d suggest omgui which has a clean and pretty API. It doesn’t, however, come with any tools.

If you need tool support, you’ll probably end up wanting to go for either MFC (resource editor built into Visual Studio) or Qt. I don’t know if wxWidgets has any tools, but I presume it has.

Edit: David Citron mentions that apparently the resource editor in Visual Studio generates Win32 compatible resource files, so that’s probably the preferred way to do things if you wanted to keep things simple.

I strongly advise against using plain Win32 because it’s pretty hard to make it work OK in all situations, it’s pretty dull and tedious work and the Common Controls library isn’t that complete. Also, most of the work has been done for you.

Every time I end up doing plain Win32 I have to spent at least a couple of hours on the most trivial tasks because I have to look up all the parameters, flags, functions, macros and figure out how to hook them up properly. I’d generally prefer a simple drag-and-drop don’t-make-me-use-my-brains type of solution and just slam the thing together in 2 minutes.

As a lightweight toolkit I’d suggest omgui which has a clean and pretty API. It doesn’t, however, come with any tools.

If you need tool support, you’ll probably end up wanting to go for either MFC (resource editor built into Visual Studio) or Qt. I don’t know if wxWidgets has any tools, but I presume it has.

Edit: David Citron mentions that apparently the resource editor in Visual Studio generates Win32 compatible resource files, so that’s probably the preferred way to do things if you wanted to keep things simple.

Создание
Windows-приложений в среде
Visual Studio

Цель
работы
Знакомство с методами визуального
программирования. Приобретение навыков
разработки приложений с графическим
интерфейсом в среде Visual
Studio
.Net
на
языке C#.

Ведение в
визуальное программирование

Визуальное
программирование —
способ создания программы для ЭВМ с
помощью манипулирования графическими
видимыми (визуальными) объектами вместо
написания программного кода. Одно из
основных назначений визуальных методов
программирования — разработка графических
интерфейсов пользователя приложения.

Средства для
организации взаимодействия с пользователем,
например окна, кнопки, меню и другие
элементы управления, называют графическим
интерфейсом пользователя (Graphical User
Interface, GUI). Windows — графическая операционная
система, поэтому говорят, что она
обеспечивает графический интерфейс
пользователя.

Средства визуальной
разработки служат сокращению затрат
времени и средств на разработку
приложения.

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

Процесс
создания Windows-приложения
состоит из двух основных этапов:

1.
Визуальное
проектирование, то
есть задание внешнего облика приложения.

2.
Определение
поведения приложения
путем написания процедур обработки
различных событий.

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

• • при щелчке мышью
  на той или иной кнопке;

• • при выборе
  определенного пункта меню;

• • по прошествии
  определенного интервала времени;

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

Такое программирование
визуального интерфейса и программного
кода называют событийно-ориентированным.

Windows Forms
— это часть.NET Framework, которая поддерживает
создание приложений со стандартным GUI
на платформе Windows. Различные элементы
управления интерфейса (кнопки, меню,
переключатели, списки, элементы ввода
и т. д.) размещаются на форме. Форма —
это окно Windows. На этапе разработки
приложения форма – это экранный объект
или контейнер, на поверхности которого
размещаются компоненты. Когда
разрабатываемая программа будет
откомпилирована и запущена на исполнение,
форма превратится в обычное окно Windows
и будет реагировать на определенные в
ней события. Таких окон в программе
может быть сколько угодно.

Среда Visual Studio.NET
предоставляет большое количество
элементов, которые можно сгруппировать
по нескольким функциональным группам.

Таблица 3.3 — Основные
группы элементов управления

Создание приложения
с графическим интерфейсом на основе
Windows Forms

Для создания
Windows-приложения,
после запуска Microsoft
Visual
Studio,
выберите в меню пункт File—New—Project.
На экране появится окно вида:

В этом и последующем
окне создания проекта следует выбрать:

• Project
  Types:
  Visual C#;

• Templates:
  Windows
  Application;

• Name:
  пишем то имя, с которым будет сформирован
  .exe файл;

• Location:
  директория в которой будет помещен
  проект;

• Можно поставить
  галочку «Create Directory for Solution»
  или задать директорию для данного
  решения в выбранной папке (кнопка
  Browse…).

• Нажимаем OK.

После выполнения
указанных действий экран примет вид:

На панелях
инструментов
находятся элементы управления
(компоненты), перетаскивая которые на
форму, можно создавать графический
интерфейс приложения Windows. Элементы
управления разбиты на категории с
логичными названиями, например Menus and
Toolbars (меню и панели инструментов), Data
(данные), Common Dialogs (диалоговые окна) и
т.д. Чтобы добавить элемент управления
на форму Windows, достаточно щелкнуть его
мышью и перетащить на форму.

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

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

Окно свойств также
можно использовать для управления
событиями Events.
Чтобы сделать это, необходимо щелкнуть
значок с изображением молнии
,
расположенный в верхней его части. С
каждым событием (например, клик мышью)
из списка событий можно связать заданный
программный код, если дважды щелкнуть
имя события.

Рассмотрим процесс
разработки простого приложения с
графическим интерфейсом.

Шаг 1. Поместите
курсор мыши на закладку ToolBox
(Панель элементов). Панель элементов
раскроется как показано на рисунке.

Шаг 2.
Раскройте раздел Common
Controls
(Обычные элементы управления) и перетащите
элемент Button
на Форму.

Шаг 3.
Убедитесь что эта кнопка выделена в
форме и отображена в окне Properties
(Свойства). Содержимое в поле свойства
Text
измените на «Щелкните здесь».

Шаг 4.
Щелкните дважды по кнопке на форме. Это
должно вызвать редактор кода, где
необходимо вписать следующий код:

Шаг 5.
Добавьте вторую форму к Вашему проекту
для этого щелкните правой кнопкой мыши
на имени решения в Solution
Explorer
(Обозревателе решений). В появившемся
меню выберите Add
(Добавить) и затем Windows
Form
(Форму Windows
Form).

Шаг 6. В
появившемся диалоговом окне Add
New
Item
(Добавление нового элемента) выберите
Windows
Form
и нажмите Add
(Добавить). Появится новая форма. В
Обозревателе решений (Solution
Explorer)
появится новый пункт – Form2.cs

Шаг 7.
Выберите вторую форму. В окне Properties
(Свойства) изменить свойство FormBorderStyle
на FixedToolWindow.

Шаг 8.
Из панели элементов перетащите на форму
элемент Label.

Шаг 9.
Измените свойство Text
объекта Label1
на «Сообщение для Вас. Щелкните по
кнопке ниже, чтобы получит его».

Шаг 10.
Перетащите на форму элемент Button
и измените свойство Text
на «Click
Me».

Шаг 11.
Щелкните дважды на кнопке — раскроется
редактор кода:

Шаг 12.
Сохраните и запустите проект на компиляцию
и исполнение.

Рассмотрим пример
разработки Windows-
приложения, вычисляющего одно из трех
выражений:

;

,

,

в зависимости от
желания пользователя.

Шаг 1.
Создайте новое Windows-приложение
С#.

Шаг 2.
Установите на форму элементы управления
как это показано на рисунке

Шаг 3.
Измените свойство Text
элементов label1,
label2,
label3
и label4
на x
=, y
=, Функция
и F
= соответственно.

Шаг 4.
Измените свойство Text
элемента button1
на текст Вычислить,
button2
— Выход.

Шаг 5.
Измените свойство Text
элемента comboBox1
на текст Выбор
функции.

Затем нажмите на
кнопке

рядом со свойством Items
элемента comboBox1
и введите три строки: F1,
F2
и F3.

Шаг 6.
Щелкните дважды на кнопке Выход,
чтобы раскрылось окно редактора кода
и впишите в обработчик события
button2_Click
код: Close(
); Этот
оператор обеспечит завершение работы
приложения при нажатии на кнопку
button2.

Шаг 7. Вернитесь
к редактору формы и щелкните дважды на
кнопке Вычислить.
Впишите в обработчик события button1_Click
следующий код:

private
void button1_Click(object sender, EventArgs e)

{

double
F=0,x,y;

if
(comboBox1.SelectedIndex == -1)

{

MessageBox.Show(«Вы
не
выбрали
вычисляемую
функцию»);

}

else

{

try

{

x
= Convert.ToDouble(textBox1.Text);

y
= Convert.ToDouble(textBox2.Text);

switch
(comboBox1.SelectedIndex)

{

case
0:

F
= (Math.Sin(x) * Math.Pow(y — 2, 0.5) )/ (x + 1.0);

break;

case
1:

F
= Math.Cos(x) / x * y * y;

break;

case
2:

F
= Math.Pow(x, 3.0 / 2.0) / 7 * y;

break;

}

textBox3.Text
= Convert.ToString(F);

}

catch
(System.FormatException)

{

MessageBox.Show(«Неверный
формат
введенных
данных»);

}

}

}

Здесь
сначала проверяется выбор пользователем
вида вычисляемой функции в элементе
comboBox1.

Блок try
содержит защищаемый код, в котором могут
происходить исключения — ошибки.
При возникновении
исключения среда CLR ищет оператор catch,
который обрабатывает это исключение.

Для определения
значений параметров x
и y
программный код обработчика обращается
к свойству Text
соответствующих элементов ввода данных
textBox1
и textBox2
и с помощью метода ToDouble()
пытается преобразовать текст в
вещественное значение.

После вычисления
функции F
результат выводится в элемент textBox3.
Для этого вещественное значение F
преобразуется в текст с помощью метода
ToString()
и вносится в свойство Text
элемента textBox3.

Шаг 8.
Запустите приложение и проверьте его
работоспособность.

Порядок выполнения
работы

1. Изучить теоретическую
   часть

2. Повторите процесс
   создания приложения с графическим
   интерфейсом, описанный во 2-м примере.

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

4. Пояснить применение
   принципов событийно-ориентированного
   подхода при разработке программы.

5. Разберите
   программный код обработчиков событий
   в созданном приложении.

6. Ответить на
   контрольные вопросы

7. Защитить работу
   у преподавателя.

Контрольные
вопросы

1. Что такое визуальное
   программирование?

2. Какие цели
   достигаются с помощью средств визуальной
   разработки?

3. Какие приемы
   используют при конструировании
   графического интерфейса с помощью
   средств визуальной разработки?

4. Что такое форма,
   компонент?

5. Какие этапы
   включает в себя разработка GUI
   приложения?

6. Какие основные
   компоненты применяются в среде Visual
   Studio
   .Net
   на языке C#
   и каково их назначение?

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

8. Какие свойства и
   методы определены для компонента
   Button?

9. Какие компоненты
   применяются для ввода и вывода данных?

10. Какие события
    способны обрабатывать компоненты?

11. Какие средства
    Visual
    Studio
    .Net
    применяются для настройки компонентов
    формы?

12. Как
    написать/отредактировать программный
    код обработчика события?

10 апреля 2020

Время чтения: 5 минут

#include "Form1.h"

#include <Windows.h>

using namespace имя_вашего_проекта;

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) {
    Application::EnableVisualStyles();
    Application::SetCompatibleTextRenderingDefault(false);
    Application::Run(gcnew Form1);
    return 0;
}

Введение

С октября 2018 года MQL5 стал нативно поддерживать интеграцию с библиотеками Net Framwork. Нативная поддержка означает что типы, методы и классы, размещенные в библиотеке .Net теперь, доступны из MQL5 программы напрямую, без предварительной декларации вызывающих функций и их параметров, а также сложного приведения типов двух языков друг к другу. Это действительно может считаться определенным прорывом, т.к. теперь гигантская кодовая база .Net Framework и мощь языка C# доступна практически «из коробки» всем пользователям MQL5.

Возможности Net Framework не ограничиваются только ей самой. Благодаря интегрированной, условно бесплатной, среде разработки VisualStudio, создание многих вещей становится гораздо проще. Например, с ее помощью в режиме drag-n-drop можно создать полноценное приложение windows, с формой и элементами на ней, которые будут вести себя привычным образом как и любое другое графическое windows-приложение. Это то, чего так не хватало в MQL.

Конечно, за годы существования этого языка, появилась ни одна и не две библиотеки, существенно облегчающие построение графического приложения внутри MQL программы. Однако, все эти библиотеки, как бы хороши они не были, представляют из себя набор кода, принцип работы с которым нужно понимать, а также уметь его интегрировать с кодом своих советников и индикаторов. Иными словами, пользователи, не знакомые с программированием, едва ли могли использовать эти библиотеки на практике. Разрыв между простотой создания форм в Visual Studio и сложностью конфигурирования графических библиотек в MQL, сохранялся бы и поныне, однако благодаря новой интеграции с библиотеками .Net Framework, простое создание форм становится реальностью. 

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

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

Особый упор в статье сделан на простоту предложенного подхода. Основная задача сделать как можно более простое взаимодействие с кодом, написанным на C#. При этом само взаимодействие организовать таким образом, чтобы код, написанный на C#, создавался автоматически, без участия пользователя! Благодаря развитым языковым средствам C#, а также богатым возможностям Visual Studio, это возможно.

Таким образом, каких-либо познаний в C# читателю данной статьи не потребуется. Главная идея будет заключаться в том, чтобы пользователь в режиме конструктора разместил графические элементы управления вроде кнопок или текстовых меток так, как ему необходимо, после чего уже на языке MQL снабдил каждый элемент соответствующей логикой. При этом все необходимые действия по интеграции панели с программой на MQL будут происходить «за кулисами», в автоматическом режиме. 

Схема взаимодействия с графическими интерфейсами .Net, общие принципы

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

Помимо перечисленных типов компилятор MQL видит массивы C#. Однако на текущий момент получить стандартный доступ к элементам массива по индексатору ‘[]’ в программе MQL пока невозможно. Можно сказать уверено, что в будущем поддержка типов будет расширяться, однако сегодняшних возможностей уже вполне достаточно для организации полноценного взаимодействия.

В нашем проекте мы будем создавать формы с помощью технологии Windows Forms. Это довольно простой набор API, который позволяет быстро, а главное просто нарисовать графический интерфейс даже неподготовленному пользователю. Его особенностью является событийно-ориентированный подход. Это значит, что когда пользователь нажимает на кнопку или вводит текст в окне ввода — в этот момент генерируется соответствующее событие. Обработав такое событие, программа написанная на C# определяет, что тот или иной графический элемент формы был изменен пользователем. Работа с событиями достаточно сложный процесс для пользователя, незнакомого с C#, поэтому необходимо написать специальный промежуточный код, который будет обрабатывать события происходящие в форме и передавать их MQL-программе, запущенной в терминале MetaTrader 5.

Таким образом, в нашем проекте будет существовать три независимых объекта, которые будут взаимодействовать друг с другом:

• Программа в виде эксперта или индикатора написанная на MQL (файл EX5), которая будет получать события от графического окна или передавать их ему с помощью специального контроллера;
• Контроллер в виде динамической библиотеки Net (DLL-файл), к которой будет обращаться MQL-программа;
• Графическое окно, созданное пользователем с помощью C#, в виде независимой программы (EXE) или динамической библиотеки (DLL), события которого будет анализировать контроллер.

Все три объекта будут взаимодействовать между собой через системы сообщений. Между программой написанной на MQL и контроллером будет действовать одна система сообщений, а между контроллером и окном пользователя — другая.

Рис. 1. Общая схема взаимодействия между MQL-программой и графическим приложением C#

Рис. 6. Создание новой учетной записи

После перехода по ссылке «Create one», начнется процесс регистрации нового почтового ящика, который будет в дальнейшем привязан ко всем сервисам Microsoft. Вам необходимо пройти регистрацию, последовательно выполняя предложенные действия. Сам процесс регистрации стандартный, поэтому мы не будет останавливаться на нем подробно.

Если регистрация Вам по каким-то причинам не подходит, просто пропустите этот шаг, нажав на ссылку «Not now, maybe later». Однако помните, что через тридцать дней Visual Studio потребует регистрацию, иначе прекратит свою работу.

Создание первой формы. Быстрый старт.

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

Итак, необходимо создать новый проект. Для этого выберем в меню  File -> New -> Project. Откроется диалоговое окно выбора типа проекта:

Рис 7.

Нам необходимо выбрать тип «Windows Form App (.Net Framework)». В поле Name необходимо ввести имя проекта. Переименуем стандартное название, выдаваемое по умолчанию, назовем наш проект GuiMT. После чего нажмем кнопку «OK». После этого в Visual Studio автоматически отобразить визуальный конструктор с автоматически созданной формой:

Рис. 8. Создание графической формы в окне Visual Studio.

В окне Solution Explorer содержится структура нашего созданного проекта. Обратите внимание на название Form1.cs — это файл, содержащий программный код, создающий графическое представление формы, которое мы видим в окне графического конструктора Form1.cs[Disign]. Запомните это название, оно нам еще понадобится.

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

Рис. 9. Выбор кнопки

Перетащим его с помощью мышки на основную поверхность нашей формы Form1:

Рис. 10. Первая форма

Размер кнопки можно также менять. Вы можете поэкспериментировать с размерам основного окна и расположением этой кнопки. Теперь, когда на форме есть кнопка, будем считать что наше первое приложение готово. Давайте скомпилируем его. Сделать это можно по-разному, но сейчас мы просто запустим его в режиме отладки, для чего нажмем кнопку Start:

Рис 11. Кнопка запуска приложения в режиме отладки.  

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

Рис. 11. Кнопка остановки отладки

Итак, наше первое приложение готово. Последнее что нам необходимо сделать, это выяснить абсолютный путь к запускаемой программе, которую мы только что создали. Самый простой способ — это просто посмотреть на путь в поле Project Folder окна Properties, при этом в окне Solution Explorer должен быть выделен проект GuiMT:

Рис. 12. Абсолютный путь к проекту приложения в графе Project Folder

Путь в этом окне относится к самому проекту. Конкретная сборка нашей программы будет располагаться в одном из подкаталогов, в зависимости от режима компиляции. В нашем случае это будет .bindebug<Название_нашего_проекта.exe>. Таким образом, полный путь к нашей программе будет: C:Users<Имя_пользователя>sourcereposGuiMTGuiMTbindebugGuiMT.exe. После того, как мы выяснили путь, его нужно будет где-то записать или запомнить, потому что позже его необходимо будет вставить в наш код на MQL.

Получение последней версии GuiController.dll. Работа с GitHub

В файлах, прикрепленных к данной статье, содержится библиотека GuiController.dll. Эту библиотеку необходимо разместить в каталоге MQL5Libraries. Однако часто бывает так, что библиотека продолжает обновляться и развиваться, в то время как к статье прикреплен уже давно устаревший архив. Чтобы избежать такой и многих других подобных ситуаций, лучше всего использовать системы контроля версий, когда новый код автоматически становится доступен для получателей. Наш проект не является исключением. Для того, чтобы гарантировано  получить самую последнюю версию GuiController, воспользуемся открытым депозитарием хранения открытых кодов GitHub.com. Исходный код этого контроллера уже содержится в данном репозитории, все что необходимо сделать — это скачать его проект и скомпилировать контроллер в динамическую библиотеку. Если по каким-то причинам Вы не можете воспользоваться этой системой или просто не хотите, то просто пропустите этот раздел. Вместо этого просто скопируйте файл GuiController.dll в каталог MQL5Libraries. 

Итак, если у Вас еще открыто текущее решение, закройте его, выполнив команду File -> Solution. Теперь перейдем на вкладку Team Explorer и нажмем ссылку Clone. В желтой графе  введите адрес, по которому  располагается проект:

https://github.com/PublicMqlProjects/MtGuiController

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

Рис. 13. Подключение к удаленному репозиторию исходного кода

Теперь, когда все готово, нажмем кнопку Clone. Через некоторое время у Вас по указанному адресу появится проект с последней версией MtGuiController. Откройте его через команду в меню File -> Open -> Project/Solution. После того как проект загружен и открыт, его необходимо скомпилировать, для чего можно нажать клавишу «F6» или выбрать в меню команду Build -> Build Solution. Найдите скомпилированный файл MtGuiController.dll в папке MtGuiControllerbindebug и скопируйте его в каталог библиотек MetaTrader 5:  MQL5Libraries.

Если по каким-то причинам Вам не удалось получить последнюю версию через github, не отчаивайтесь. В этом случае скопируйте контроллер из архива, прикрепленный к данной статье.

Интеграция первого приложения с MetaTrader 5

Теперь, когда у нас есть первое приложение и контроллер, который будет транслировать сигналы графического окна в MetaTrader, нам осталось выполнить заключительную часть: написать программу на MQL в виде эксперта, которая бы получала события от нашего окна через контроллер. Создадим новый эксперт в MetaEditor с именем GuiMtController со следующим содержимым:

#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";



int OnInit()
  {

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

   return(INIT_SUCCEEDED);
  }



void OnDeinit(const int reason)
  {

   GuiController::HideForm(assembly, "Form1");
   EventKillTimer();   
  }



void OnTick()
{

}



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);
   }
  }

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

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

нужно скорректировать на путь к фактическому расположению Вашей программы с окном.
Если все сделано правильно, эксперт скомпилируется, а после его запуска на фоне главного окна MetaTrader появится наше окошко:

Рис. 14. Эксперт с интегрированным графическим приложением на C#.

Обратите внимание, что если нажать на кнопку button1, то эксперт выведет на вкладке Experts надпись «Click on element button1», сигнализируя о том, что он получил событие нажатие кнопки. 

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

int OnInit()
  {

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

   return(INIT_SUCCEEDED);
  }

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

partial class Form1
{
        
        
        
        private System.ComponentModel.IContainer components = null;
        ...
}

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);
   }

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

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

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

public enum GuiEventType
{
    Exception,
    ClickOnElement,
    TextChange,
    ScrollChange
}

for(static int i = 0; i < GuiController::EventsTotal(); i++)

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;
}

private static Form FindForm(Assembly assembly, string form_name)
{
    Type[] types = assembly.GetTypes();
    foreach (Type type in types)
    {
        
        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");
}

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);
    }
}
        



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);
    }
}

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);
        }
    }
}

Следует различать текст, который изображен на элементе и имя самого элемента. Это разные значения, хотя они зачастую имеют схожий смысл.

Приведем список элементов, которые содержит наша торговая панель:

• Основное графическое окно (Form) c именем TradePanelForm, на котором располагаются все остальные элементы управления.
• Красная текстовая метка (Label), с именем AskLabel. Данная метка будет отображать цену Ask текущего инструмента;
• Cиняя текстовая метка (Label), с именем BidLabel. Данная метка будет отображать цену Bid текущего инструмента;
• Поле ввода текста (TextBox) с именем CurrentVolume. В данное поле пользователь будет вводить нужный объем сделки;
• Вертикальный Скролл (VScrollBar) с именем IncrementVol. Данный скролл будет увеличивать или уменьшать объем на один шаг. Величина шага будет определятся MQL-программой, на основе текущего торгового окружения.
• Кнопка покупки с именем ButtonBuy. Нажав на эту кнопку пользователь купит заданный им объем по цене Ask — той, что отображается на красной текстовой метке.
• Кнопка продажи с именем ButtonSell. Нажав на эту кнопку пользователь продаст заданный им объем по цене Bid, которая будет отображаться на синей текстовой метке.

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


CTrade Trade;  



int OnInit()
{

   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);
}



void OnDeinit(const int reason)
  {

   EventKillTimer();
   GuiController::HideForm(assembly, FormName);

  }



void OnTick()
{

   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()));

}




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 == TextChange && el_name == "CurrentVolume")
         TrySetNewVolume(sparam);
      else if(id == ScrollChange && el_name == "IncrementVol")
         OnIncrementVolume(lparam, dparam, sparam);
      else if(id == ClickOnElement)
         TryTradeOnClick(el_name);
   }

}



double ValidateVolume(double n_vol)
{
   double min_vol = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN);
   double max_vol = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX);
   
   if(n_vol < min_vol)
      return min_vol;
   
   if(n_vol > max_vol)
      return max_vol;
   
   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;
}



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;
}



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;
}



void OnIncrementVolume(long lparam, double dparam, string sparam)
{
   double vol_step = 0.0;
   
   if(dparam > lparam)
      vol_step = (-1.0) * SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
   
   else if(dparam < lparam)
      vol_step = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
   
   else if(lparam == 0)
      vol_step = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
   
   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);
}

GuiController::ShowForm(assembly, FormName);

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

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()));

В статье был предложен подход с помощью которого быстро, а главное — легко, можно создать свою собственную визуальную форму. Данный подход разделяет графическое приложение на три независимые части: MQL-программу, адаптер GuiController и собственно визуальную панель. Все части приложения не зависят друг от друга. MQL-программа работает в торговом окружении MetaTrader и выполняет торговые или аналитические функции исходя из тех параметров, что она получает от панели через GuiController. Сам GuiController является назависимой программой, которую не требуется изменять при изменении формы или ее элементов. Наконец, графическая панель создается самим пользователем, с помощью развитых визуальных средств Visual Studio. Благодаря этому, для создания довольно сложной формы может даже не потребоваться знание языка программирования C#.

Сами созданные формы никак не зависят от той программы, которая их запускает. Это может быть сам MetaTrader 5 или его тестер стратегий — окно и в том и в другом случае будет работать согласно заложенной в него логике. Помимо этого, окно не зависит и от того, в какой именно функции оно вызвано. Благодаря этому графические интерфейсы одинаково хорошо работают как в самом MetaTrader 5 так и в его тестере стратегий, при этом без разницы работает ли с окном эксперт или индикатор. Во всех случаях поведение окна будет одинаковым.

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

У предложенного подхода, как и у любой технологии, есть свои недостатки. Основной из них это невозможность работы в Маркете, т.к. вызов сторонних DLL запрещен. Во-вторых, запуск незнакомых DLL или EXE может быть небезопасным, т.к. эти модули могут содержать вредоносные функции. Однако данная проблема решается открытостью проекта. Пользователь знает, что созданная им программа априори не содержит иных элементов, кроме заданных им самим, а GuiController — это публичный проект с открытым исходным кодом. Еще одним недостатком является то, что межпрограммное взаимодействие достаточно сложный процесс. Такое взаимодействие может вызвать зависание или непредвиденное завершение работы программы. Многое зависит от разработчика, который будет разрабатывать интерфейс и взаимодействие с ним. Такую систему легче вывезти из строя, чем монолитную, написанную на чистом MQL5.

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