Встраивание торговой дисциплины в код (Часть 3): Принудительное ограничение торговли на уровне символов с помощью белого списка в MQL5

MetaTrader 5 — Торговые системы | 8 июля 2026, 12:58

Christian Benjamin

Содержание

Введение

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

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

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

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

Ознакомление с концепцией

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

Почему важна дисциплина в работе с символами

Одна из наиболее распространенных областей, где дисциплина нарушается, — это выбор символов. Многие трейдеры начинают с определенного набора валютных пар или инструментов, в которых они хорошо разбираются. Со временем они изучают поведение этих символов в разные торговые сессии, их реакцию на новости, их волатильность и то, насколько четко формируются их торговые сигналы. Такое знакомство с инструментами создает статистическую уверенность и позволяет принимать структурированные решения. Однако современные торговые платформы предоставляют доступ к десяткам, а иногда и сотням инструментов. Одним движением колеса мыши трейдер может перейти от EURUSD к NASDAQ, от золота к экзотическим валютным парам.

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

Со временем это приводит к следующим последствиям:

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

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

Белый список символов

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

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

Структура принятия решений является бинарной и детерминистской:

Если символ входит в белый список, исполнение продолжается.
Если символ не входит в белый список, исполнение автоматически отклоняется.

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

Белый список символов против черного списка

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

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

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

Почему важно принудительное применение правил на уровне кода

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

Благодаря внедрению проверки модели белого списка в конвейер выполнения допустимость инструмента становится контролируемым параметром, а не регулируемой переменной. Система не оценивает, “выглядит ли торговый сетап корректным” для неутвержденного символа. Она просто проверяет статус авторизации, прежде чем продолжить. Это гарантирует, что логика стратегии работает строго в рамках исследованной и протестированной области.

Преимущества модели белого списка

При реализации в качестве части торговой инфраструктуры принудительное применение правил белого списка обеспечивает измеримые операционные преимущества:

Преимущество	Оперативное влияние
Определенный набор торговых инструментов	Исполнение остается ограниченным инструментами, первоначально исследованными и проверенными.
Защита от расширения области действия	Предотвращает незапланированное включение дополнительных или вновь добавленных символов.
Целостность бэктестинга	Гарантирует, что результаты работы не будут искажены непредусмотренными инструментами.
Контроль над уровнем риска	Удерживает совокупную рыночную экспозицию в заранее заданных пределах.
Ответственность за конфигурацию	Делает набор утвержденных инструментов прозрачным и доступным для проверки.
Безопасность развертывания	Блокирует исполнение ордера, если советник подключен к неавторизованному графику.
Структурное управление	Вводит основанный на правилах контроль, сопоставимый с институциональными фильтрами рисков.
Готовность к аудиту	Позволяет логирование отклоненных символов для мониторинга и оценки.

Оперативный результат

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

Обзор архитектуры системы

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

Архитектура состоит из:

Основной подключаемый файл - SymbolWhitelist.mqh
Индикатор дашборда - SymbolWhitelistDashboard.mq5
Советник-принудитель - SymbolWhitelistEnforcer.mq5

Все компоненты взаимодействуют посредством файлов постоянного хранения (SymbolWhitelist.txt и SymbolWhitelistLog.csv), которые функционируют как общий слой состояния системы.

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

1. Основной подключаемый файл - SymbolWhitelist.mqh

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

Ее обязанности организованы в три функциональные области.

Управление белым списком

Библиотека управляет сохранением утвержденных символов. Функция SaveWhitelist() записывает настроенный список символов в файл SymbolWhitelist.txt, а функция LoadWhitelist() извлекает его при необходимости. Для обеспечения надежности функция ParseWhitelist() преобразует сохраненную строку, разделенную запятыми, в правильно обрезанный массив, что позволяет гибко форматировать пользовательский ввод без нарушения логики проверки.

Валидация символа

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

Логирование и аудит

Для обеспечения прозрачности функция LogBlockedAttempt() записывает каждую отклоненную попытку совершения сделки в файл SymbolWhitelistLog.csv, включая временную метку, символ и источник сделки (ручная торговля или торговля с помощью советника). Функция ReadLog() извлекает последние записи для отображения на дашборде. Этот механизм обеспечивает отслеживаемость и операционную подотчетность.

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

2. Индикатор дашборда - SymbolWhitelistDashboard.mq5

Дашборд обеспечивает управление конфигурацией и наглядное отображение состояния в реальном времени. Он не мешает торговым операциям; напротив, преобразует состояние системы в доступный визуальный формат. Во время инициализации дашборд принимает параметр InpWhitelist и записывает утвержденные символы в общий файл, используя основную библиотеку. Это действие задаёт рабочий периметр всей системы.

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

Список утвержденных символов
Статус авторизации текущего графика
Последние заблокированные попытки
Подтверждение статуса принудительного выполнения правил

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

3. Советник-принудитель - SymbolWhitelistEnforcer.mq5

Советник-принудитель — это активный уровень управления, отвечающий за применение ограничений. Он работает независимо от дашборда и сосредоточен исключительно на мониторинге и корректирующих действиях. После инициализации советник подтверждает активацию, а затем отслеживает события OnTradeTransaction, генерируемые терминалом MetaTrader 5. Он специально оценивает новые отложенные ордера (TRADE_TRANSACTION_ORDER_ADD) и исполненные рыночные сделки (TRADE_TRANSACTION_DEAL_ADD).

Для каждого соответствующего события советник извлекает символ и вызывает функцию IsSymbolAllowed() из основной библиотеки. Если символ авторизован, никакие действия не предпринимаются.

Если символ не разрешен, советник немедленно:

Логирует попытку с помощью LogBlockedAttempt()
Отменяет отложенные ордера или закрывает открытые позиции
Выводит подтверждающее сообщение в лог советника

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

Интегрированное поведение системы

Работа системы строится по чёткой последовательности. Белый список определяется через дашборд. Основная библиотека хранит и стандартизирует логику проверки. Советник-принудитель отслеживает торговую активность и применяет ограничения при необходимости. Любая заблокированная попытка логируется и отображается дашбордом. Такое разделение гарантирует, что конфигурация, проверка, принудительное применение правил и отчетность остаются независимыми, но синхронизированными.

Реализация на MQL5

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

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

Часть 1 — Основной движок (SymbolWhitelist.mqh)

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

Выделенное пространство имен SWL изолирует все функции, предотвращая конфликты имен с другими торговыми утилитами. Две константы, WHITELIST_FILE и LOG_FILE, определяют текстовый файл и CSV-файл, используемые для сохранения конфигурации и логов событий. Такая структура гарантирует, что система остается удобочитаемой, доступной для проверки и редактирования при необходимости, при этом полностью совместимой с операциями в среде выполнения.

//+------------------------------------------------------------------+
//|                                               SymbolWhitelist.mqh|
//|                                   Copyright 2026, MetaQuotes Ltd.|
//|                           https://www.mql5.com/ru/users/lynnchris|
//+------------------------------------------------------------------+
namespace SWL
  {
const string WHITELIST_FILE = "SymbolWhitelist.txt";
const string LOG_FILE       = "SymbolWhitelistLog.csv";

Сохранение белого списка - SaveWhitelist()

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

//+------------------------------------------------------------------+
//| Saves the whitelist string to file                               |
//+------------------------------------------------------------------+
bool SaveWhitelist(string whitelist)
  {
   int handle = FileOpen(WHITELIST_FILE,FILE_TXT|FILE_WRITE);
   if(handle==INVALID_HANDLE)
      return false;
   FileWrite(handle,whitelist);
   FileClose(handle);
   return true;
  }
//+------------------------------------------------------------------+

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

Загрузка белого списка - LoadWhitelist()

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

//+------------------------------------------------------------------+
//| Loads the whitelist from file, returns as string                 |
//+------------------------------------------------------------------+
string LoadWhitelist()
  {
   if(!FileIsExist(WHITELIST_FILE))
      return "";
   int handle = FileOpen(WHITELIST_FILE,FILE_TXT|FILE_READ);
   if(handle==INVALID_HANDLE)
      return "";
   string data = FileReadString(handle);
   FileClose(handle);
   return data;
  }
//+------------------------------------------------------------------+

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

Разбор белого списка - ParseWhitelist()

Хотя белый список хранится в виде простой строки, разделенной запятыми, функция ParseWhitelist() преобразует ее в чистый массив отдельных символов. Она использует StringSplit() для извлечения каждой записи и удаляет пробелы с помощью StringTrimLeft() и StringTrimRight(). Пустые записи игнорируются, обеспечивая надежный и согласованный массив независимо от формата ввода пользователя.

//+------------------------------------------------------------------+
//| Parses a comma‑separated whitelist into an array of symbols      |
//+------------------------------------------------------------------+
int ParseWhitelist(string list,string &result[])
  {
   ArrayResize(result,0);
   if(list=="")
      return 0;
   string parts[];
   int count = StringSplit(list,',',parts);
   for(int i=0; i<count; i++)
     {
      string trimmed = parts[i];
      StringTrimLeft(trimmed);
      StringTrimRight(trimmed);
      if(trimmed!="")
        {
         int sz = ArraySize(result);
         ArrayResize(result,sz+1);
         result[sz] = trimmed;
        }
     }
   return ArraySize(result);
  }
//+------------------------------------------------------------------+

Например, вы можете ввести "EURUSD, GBPUSD , XAUUSD" с непоследовательными пробелами. ParseWhitelist() стандартизирует запись до ["EURUSD","GBPUSD","XAUUSD"], предотвращая потенциальные несоответствия или ошибки при применении правил. Такое внимание к деталям гарантирует удобство использования системы и снижает количество человеческих ошибок.

Проверка на разрешение символа-IsSymbolAllowed()

Функция IsSymbolAllowed() инкапсулирует проверку на принудительное применение правил. Она загружает и анализирует белый список, затем перебирает элементы массива, выполняя сравнение с предоставленным символом без учета регистра. Если найдено совпадение, то она возвращает значение true. В противном случае возвращается значение false.

//+------------------------------------------------------------------+
//| Checks if a given symbol is in the whitelist                     |
//+------------------------------------------------------------------+
bool IsSymbolAllowed(string symbol)
  {
   string list = LoadWhitelist();
   string allowed[];
   ParseWhitelist(list,allowed);
   for(int i=0; i<ArraySize(allowed); i++)
      if(StringCompare(allowed[i],symbol,false)==0)
         return true;
   return false;
  }
//+------------------------------------------------------------------+

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

Логирование заблокированных попыток - LogBlockedAttempt()

При блокировании сделки LogBlockedAttempt() записывает каждую отклоненную попытку совершения сделки в файл SymbolWhitelistLog.csv, включая временную метку, символ и источник сделки (ручная торговля или торговля с помощью советника). Этот прозрачный аудиторский след позволяет трейдерам просматривать действия по применению правил, выявлять импульсивные модели поведения и подтверждать эффективность системы.

//+------------------------------------------------------------------+
//| Appends a blocked attempt to the log file                        |
//+------------------------------------------------------------------+
void LogBlockedAttempt(datetime time,string symbol,string source)
  {
   int handle = FileOpen(LOG_FILE,FILE_TXT|FILE_READ|FILE_WRITE|FILE_CSV,',');
   if(handle==INVALID_HANDLE)
      return;
   FileSeek(handle,0,SEEK_END);
   FileWrite(handle,TimeToString(time),symbol,source);
   FileClose(handle);
  }
//+------------------------------------------------------------------+

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

Считывание истории лога - ReadLog()

Дашборд использует функцию ReadLog() для отображения самых последних заблокированных попыток. Он считывает CSV-файл и возвращает записи в обратном хронологическом порядке, ограничивая отображение настраиваемым максимумом (по умолчанию 10). Это обеспечивает краткую и актуальную визуальную запись, которая укрепляет дисциплину и предотвращает информационную перегрузку.

//+------------------------------------------------------------------+
//| Reads the last N log entries (most recent first)                 |
//+------------------------------------------------------------------+
int ReadLog(string &times[],string &symbols[],string &sources[],int max=10)
  {
   ArrayResize(times,0);
   ArrayResize(symbols,0);
   ArrayResize(sources,0);
   if(!FileIsExist(LOG_FILE))
      return 0;

   int handle = FileOpen(LOG_FILE,FILE_TXT|FILE_READ|FILE_CSV,',');
   if(handle==INVALID_HANDLE)
      return 0;

   string tmpTime[], tmpSym[], tmpSrc[];
   while(!FileIsEnding(handle))
     {
      string t = FileReadString(handle);
      string s = FileReadString(handle);
      string src = FileReadString(handle);
      if(t!="" && s!="")
        {
         int sz = ArraySize(tmpTime);
         ArrayResize(tmpTime,sz+1);
         ArrayResize(tmpSym,sz+1);
         ArrayResize(tmpSrc,sz+1);
         tmpTime[sz] = t;
         tmpSym[sz] = s;
         tmpSrc[sz] = src;
        }
     }
   FileClose(handle);

   int total = ArraySize(tmpTime);
   int start = (total>max) ? total-max : 0;
   for(int i=total-1; i>=start; i--)
     {
      int sz = ArraySize(times);
      ArrayResize(times,sz+1);
      ArrayResize(symbols,sz+1);
      ArrayResize(sources,sz+1);
      times[sz] = tmpTime[i];
      symbols[sz] = tmpSym[i];
      sources[sz] = tmpSrc[i];
     }
   return ArraySize(times);
  }
  }
//+------------------------------------------------------------------+

Часть 2 - Индикатор дашборда (SymbolWhitelistDashboard.mq5)

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

//+------------------------------------------------------------------+
//|                                      SymbolWhitelistDashboard.mq5|
//|                                   Copyright 2026, MetaQuotes Ltd.|
//|                           https://www.mql5.com/ru/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Christian Benjamin"
#property link      "https://www.mql5.com/ru/users/lynnchris"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 0
#property indicator_plots   0

#include <SymbolWhitelist.mqh>

//--- input parameters
input string InpWhitelist = "EURUSD,GBPUSD,XAUUSD";   // Allowed symbols (comma separated)
input int    InpX         = 20;                       // Panel X offset
input int    InpY         = 20;                       // Panel Y offset
input int    InpWidth     = 500;                      // Panel width
input int    InpHeight    = 300;                      // Panel height

//--- colors
input color  InpBgColor       = C'30,30,30';          // Background
input color  InpBorderColor   = C'80,80,80';          // Border
input color  InpChipBg        = C'70,70,70';          // Chip background
input color  InpChipBorder    = C'120,120,120';       // Chip border
input color  InpTextColor     = clrWhite;             // Text
input color  InpAllowedColor  = clrLimeGreen;         // Allowed indicator
input color  InpBlockedColor  = clrTomato;            // Blocked indicator
input color  InpActiveColor   = clrLimeGreen;         // Enforcement active

//--- global prefixes
string PREFIX = "SWL_";

Инициализация - OnInit()

После подключения функция OnInit() записывает входной белый список в общий файл через SWL::SaveWhitelist(), обеспечивая согласование с модулем контроля. Затем она отображает панель и запускает секундный таймер. Этот таймер управляет обновлениями в реальном времени, позволяя динамически обновлять отображение без блокировки нормальной работы графика.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   //--- Save initial whitelist to file
   SWL::SaveWhitelist(InpWhitelist);

   CreatePanel();
   EventSetTimer(1);
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   EventKillTimer();
   DeleteObjectsByPrefix(PREFIX);
  }
//+------------------------------------------------------------------+

Обновления таймера - OnTimer() и UpdateDashboard()

Каждую секунду таймер запускает функцию UpdateDashboard(). Функция перезагружает белый список и лог, обновляя визуальные элементы в соответствии с текущим состоянием системы. Этот цикл обратной связи в реальном времени постоянно визуально подтверждает соблюдение торговой дисциплины, показывая, какие сделки разрешены, а какие заблокированы.

//+------------------------------------------------------------------+
//| Custom indicator iteration function (required)                   |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   return(rates_total);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   UpdateDashboard();
  }
//+------------------------------------------------------------------+

Рисование панели - CreatePanel()

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

//+------------------------------------------------------------------+
//| Creates the entire panel                                         |
//+------------------------------------------------------------------+
void CreatePanel()
  {
   DeleteObjectsByPrefix(PREFIX);

   //--- Background
   ObjectCreate(0,PREFIX+"BG",OBJ_RECTANGLE_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"BG",OBJPROP_XDISTANCE,InpX);
   ObjectSetInteger(0,PREFIX+"BG",OBJPROP_YDISTANCE,InpY);
   ObjectSetInteger(0,PREFIX+"BG",OBJPROP_XSIZE,InpWidth);
   ObjectSetInteger(0,PREFIX+"BG",OBJPROP_YSIZE,InpHeight);
   ObjectSetInteger(0,PREFIX+"BG",OBJPROP_BGCOLOR,InpBgColor);
   ObjectSetInteger(0,PREFIX+"BG",OBJPROP_BORDER_TYPE,BORDER_FLAT);
   ObjectSetInteger(0,PREFIX+"BG",OBJPROP_COLOR,InpBorderColor);
   ObjectSetInteger(0,PREFIX+"BG",OBJPROP_BACK,false);

   //--- Header
   ObjectCreate(0,PREFIX+"HEADER",OBJ_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"HEADER",OBJPROP_XDISTANCE,InpX+10);
   ObjectSetInteger(0,PREFIX+"HEADER",OBJPROP_YDISTANCE,InpY+8);
   ObjectSetString(0,PREFIX+"HEADER",OBJPROP_TEXT,"SYMBOL WHITELIST ENFORCER");
   ObjectSetInteger(0,PREFIX+"HEADER",OBJPROP_COLOR,InpTextColor);
   ObjectSetInteger(0,PREFIX+"HEADER",OBJPROP_FONTSIZE,12);
   ObjectSetInteger(0,PREFIX+"HEADER",OBJPROP_BACK,false);
   ObjectSetInteger(0,PREFIX+"HEADER",OBJPROP_SELECTABLE,false);

   //--- Separator line
   ObjectCreate(0,PREFIX+"SEP1",OBJ_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"SEP1",OBJPROP_XDISTANCE,InpX+10);
   ObjectSetInteger(0,PREFIX+"SEP1",OBJPROP_YDISTANCE,InpY+30);
   ObjectSetString(0,PREFIX+"SEP1",OBJPROP_TEXT,"────────────────────");
   ObjectSetInteger(0,PREFIX+"SEP1",OBJPROP_COLOR,InpBorderColor);
   ObjectSetInteger(0,PREFIX+"SEP1",OBJPROP_BACK,false);
   ObjectSetInteger(0,PREFIX+"SEP1",OBJPROP_SELECTABLE,false);

   //--- Allowed symbols section header
   ObjectCreate(0,PREFIX+"ALLOWED_TITLE",OBJ_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"ALLOWED_TITLE",OBJPROP_XDISTANCE,InpX+10);
   ObjectSetInteger(0,PREFIX+"ALLOWED_TITLE",OBJPROP_YDISTANCE,InpY+40);
   ObjectSetString(0,PREFIX+"ALLOWED_TITLE",OBJPROP_TEXT,"ALLOWED SYMBOLS");
   ObjectSetInteger(0,PREFIX+"ALLOWED_TITLE",OBJPROP_COLOR,InpTextColor);
   ObjectSetInteger(0,PREFIX+"ALLOWED_TITLE",OBJPROP_FONTSIZE,10);
   ObjectSetInteger(0,PREFIX+"ALLOWED_TITLE",OBJPROP_BACK,false);
   ObjectSetInteger(0,PREFIX+"ALLOWED_TITLE",OBJPROP_SELECTABLE,false);

   //--- Current chart section header
   ObjectCreate(0,PREFIX+"CURRENT_TITLE",OBJ_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"CURRENT_TITLE",OBJPROP_XDISTANCE,InpX+10);
   ObjectSetInteger(0,PREFIX+"CURRENT_TITLE",OBJPROP_YDISTANCE,InpY+95);
   ObjectSetString(0,PREFIX+"CURRENT_TITLE",OBJPROP_TEXT,"CURRENT CHART");
   ObjectSetInteger(0,PREFIX+"CURRENT_TITLE",OBJPROP_COLOR,InpTextColor);
   ObjectSetInteger(0,PREFIX+"CURRENT_TITLE",OBJPROP_FONTSIZE,10);
   ObjectSetInteger(0,PREFIX+"CURRENT_TITLE",OBJPROP_BACK,false);
   ObjectSetInteger(0,PREFIX+"CURRENT_TITLE",OBJPROP_SELECTABLE,false);

   //--- Log section header
   ObjectCreate(0,PREFIX+"LOG_TITLE",OBJ_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"LOG_TITLE",OBJPROP_XDISTANCE,InpX+10);
   ObjectSetInteger(0,PREFIX+"LOG_TITLE",OBJPROP_YDISTANCE,InpY+150);
   ObjectSetString(0,PREFIX+"LOG_TITLE",OBJPROP_TEXT,"TODAY'S BLOCKED ATTEMPTS");
   ObjectSetInteger(0,PREFIX+"LOG_TITLE",OBJPROP_COLOR,InpTextColor);
   ObjectSetInteger(0,PREFIX+"LOG_TITLE",OBJPROP_FONTSIZE,10);
   ObjectSetInteger(0,PREFIX+"LOG_TITLE",OBJPROP_BACK,false);
   ObjectSetInteger(0,PREFIX+"LOG_TITLE",OBJPROP_SELECTABLE,false);

   //--- Footer (enforcement status)
   ObjectCreate(0,PREFIX+"FOOTER",OBJ_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"FOOTER",OBJPROP_XDISTANCE,InpX+10);
   ObjectSetInteger(0,PREFIX+"FOOTER",OBJPROP_YDISTANCE,InpY+InpHeight-25);
   ObjectSetInteger(0,PREFIX+"FOOTER",OBJPROP_COLOR,InpActiveColor);
   ObjectSetInteger(0,PREFIX+"FOOTER",OBJPROP_FONTSIZE,11);
   ObjectSetInteger(0,PREFIX+"FOOTER",OBJPROP_BACK,false);
   ObjectSetInteger(0,PREFIX+"FOOTER",OBJPROP_SELECTABLE,false);

   //--- Dynamic elements (chips, status, log lines)
   for(int i=0; i<10; i++)
     {
      string name = PREFIX+"CHIP_"+IntegerToString(i);
      ObjectCreate(0,name,OBJ_RECTANGLE_LABEL,0,0,0);
      ObjectSetInteger(0,name,OBJPROP_BGCOLOR,InpChipBg);
      ObjectSetInteger(0,name,OBJPROP_BORDER_TYPE,BORDER_FLAT);
      ObjectSetInteger(0,name,OBJPROP_COLOR,InpChipBorder);
      ObjectSetInteger(0,name,OBJPROP_BACK,false);
      ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
      ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);

      name = PREFIX+"CHIPTXT_"+IntegerToString(i);
      ObjectCreate(0,name,OBJ_LABEL,0,0,0);
      ObjectSetInteger(0,name,OBJPROP_COLOR,InpTextColor);
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,10);
      ObjectSetInteger(0,name,OBJPROP_BACK,false);
      ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
      ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);

      name = PREFIX+"LOG_"+IntegerToString(i);
      ObjectCreate(0,name,OBJ_LABEL,0,0,0);
      ObjectSetInteger(0,name,OBJPROP_COLOR,InpTextColor);
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,9);
      ObjectSetString(0,name,OBJPROP_FONT,"Consolas");
      ObjectSetInteger(0,name,OBJPROP_BACK,false);
      ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
      ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
     }

   //--- Status lines
   ObjectCreate(0,PREFIX+"STATUS_SYM",OBJ_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"STATUS_SYM",OBJPROP_COLOR,InpTextColor);
   ObjectSetInteger(0,PREFIX+"STATUS_SYM",OBJPROP_FONTSIZE,10);
   ObjectSetInteger(0,PREFIX+"STATUS_SYM",OBJPROP_BACK,false);
   ObjectSetInteger(0,PREFIX+"STATUS_SYM",OBJPROP_SELECTABLE,false);

   ObjectCreate(0,PREFIX+"STATUS_IND",OBJ_LABEL,0,0,0);
   ObjectSetInteger(0,PREFIX+"STATUS_IND",OBJPROP_FONTSIZE,10);
   ObjectSetInteger(0,PREFIX+"STATUS_IND",OBJPROP_BACK,false);
   ObjectSetInteger(0,PREFIX+"STATUS_IND",OBJPROP_SELECTABLE,false);

   UpdateDashboard();
  }
//+------------------------------------------------------------------+

Отображение разрешенных символов - Визуализация символов в виде чипов

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

//+------------------------------------------------------------------+
//| Updates all dynamic panel content                                |
//+------------------------------------------------------------------+
void UpdateDashboard()
  {
   string whitelist = SWL::LoadWhitelist();
   string allowed[];
   int num = SWL::ParseWhitelist(whitelist,allowed);

   //--- Hide all chips first
   for(int i=0; i<10; i++)
     {
      ObjectSetInteger(0,PREFIX+"CHIP_"+IntegerToString(i),OBJPROP_HIDDEN,true);
      ObjectSetInteger(0,PREFIX+"CHIPTXT_"+IntegerToString(i),OBJPROP_HIDDEN,true);
     }

   //--- Draw chips
   int x = InpX + 10;
   int y = InpY + 55;
   int chipHeight = 22;
   int margin = 8;
   for(int i=0; i<num && i<10; i++)
     {
      string sym = allowed[i];
      int textWidth = StringLen(sym) * 7;
      int chipWidth = textWidth + 16;

      if(x + chipWidth > InpX + InpWidth - 10)
        {
         x = InpX + 10;
         y += chipHeight + 5;
        }

      string chipName = PREFIX+"CHIP_"+IntegerToString(i);
      ObjectSetInteger(0,chipName,OBJPROP_XDISTANCE,x);
      ObjectSetInteger(0,chipName,OBJPROP_YDISTANCE,y);
      ObjectSetInteger(0,chipName,OBJPROP_XSIZE,chipWidth);
      ObjectSetInteger(0,chipName,OBJPROP_YSIZE,chipHeight);
      ObjectSetInteger(0,chipName,OBJPROP_HIDDEN,false);

      string txtName = PREFIX+"CHIPTXT_"+IntegerToString(i);
      ObjectSetInteger(0,txtName,OBJPROP_XDISTANCE,x+8);
      ObjectSetInteger(0,txtName,OBJPROP_YDISTANCE,y+3);
      ObjectSetString(0,txtName,OBJPROP_TEXT,sym);
      ObjectSetInteger(0,txtName,OBJPROP_HIDDEN,false);

      x += chipWidth + margin;
     }

Текущий статус графика - динамическая обратная связь

Дашборд проверяет символ графика, к которому он прикреплен, и отображает зеленый индикатор "РАЗРЕШЕНО" или красный индикатор "ЗАБЛОКИРОВАНО". Позиционирование динамически корректируется для предотвращения перекрытий, а длинные названия символов аккуратно обрезаются. Трейдеры могут сразу увидеть, входит ли текущий график в белый список, что исключает ошибки, вызванные невнимательностью или импульсивными решениями.

   //--- Current chart status with dynamic positioning
   string currSym = Symbol();
   bool allowedNow = SWL::IsSymbolAllowed(currSym);
   string statusText = allowedNow ? "ALLOWED" : "BLOCKED";
   color statusColor = allowedNow ? InpAllowedColor : InpBlockedColor;

   int statusWidth = StringLen(statusText) * 8;
   int statusX = InpX + InpWidth - statusWidth - 40;
   if(statusX < InpX + 10)
      statusX = InpX + 10;

   int maxSymbolWidth = statusX - (InpX + 10) - 10;
   int maxChars = maxSymbolWidth / 7;
   string prefix = "Symbol: ";
   int prefixLen = StringLen(prefix);
   int symLen = StringLen(currSym);

   string displaySym;
   if(prefixLen + symLen <= maxChars)
      displaySym = prefix + currSym;
   else
     {
      int availableForSym = maxChars - prefixLen - 3;
      if(availableForSym < 1)
         availableForSym = 1;
      string truncated = StringSubstr(currSym,0,availableForSym) + "...";
      displaySym = prefix + truncated;
     }

   ObjectSetInteger(0,PREFIX+"STATUS_SYM",OBJPROP_XDISTANCE,InpX+10);
   ObjectSetInteger(0,PREFIX+"STATUS_SYM",OBJPROP_YDISTANCE,InpY+110);
   ObjectSetString(0,PREFIX+"STATUS_SYM",OBJPROP_TEXT,displaySym);

   ObjectSetInteger(0,PREFIX+"STATUS_IND",OBJPROP_XDISTANCE,statusX);
   ObjectSetInteger(0,PREFIX+"STATUS_IND",OBJPROP_YDISTANCE,InpY+110);
   ObjectSetString(0,PREFIX+"STATUS_IND",OBJPROP_TEXT,statusText);
   ObjectSetInteger(0,PREFIX+"STATUS_IND",OBJPROP_COLOR,statusColor);

Отображение логов — записи в виде выровненных столбцов

Дашборд отображает недавние заблокированные попытки в выровненных столбцах с использованием моноширинного шрифта. Каждая строка отображает время (ЧЧ:ММ), название символа с отступом и значок, указывающий на ручной ввод или использование советника. Такая лаконичная компоновка обеспечивает быстрое понимание и повышает прозрачность и подотчетность системы.

   //--- Log entries with fixed‑width columns (monospaced font)
   string times[], symbols[], sources[];
   int logCount = SWL::ReadLog(times,symbols,sources,5);
   int logY = InpY + 165;
   for(int i=0; i<5; i++)
     {
      string name = PREFIX+"LOG_"+IntegerToString(i);
      if(i < logCount)
        {
         string timePart = StringSubstr(times[i],11,5);
         string symPart = symbols[i];
         string icon = (sources[i] == "manual" ? "M" : "EA");

         int symLen = StringLen(symPart);
         if(symLen < 30)
           {
            for(int j=symLen; j<30; j++)
               symPart += " ";
           }
         else if(symLen > 30)
               symPart = StringSubstr(symPart,0,30);

         string text = StringFormat("%s  %s  %s",timePart,symPart,icon);
         ObjectSetString(0,name,OBJPROP_TEXT,text);
         ObjectSetInteger(0,name,OBJPROP_XDISTANCE,InpX+10);
         ObjectSetInteger(0,name,OBJPROP_YDISTANCE,logY + i*16);
         ObjectSetInteger(0,name,OBJPROP_HIDDEN,false);
        }
      else
         ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
     }

   ObjectSetString(0,PREFIX+"FOOTER",OBJPROP_TEXT,"ENFORCEMENT: ● ACTIVE");
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Deletes all objects with a given prefix                          |
//+------------------------------------------------------------------+
void DeleteObjectsByPrefix(string prefix)
  {
   for(int i=ObjectsTotal(0)-1; i>=0; i--)
     {
      string name = ObjectName(0,i);
      if(StringFind(name,prefix) == 0)
         ObjectDelete(0,name);
     }
  }
//+------------------------------------------------------------------+

Часть 3 - Советник-принудитель (SymbolWhitelistEnforcer.mq5)

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

//+------------------------------------------------------------------+
//|                                      SymbolWhitelistEnforcer.mq5|
//|                                   Copyright 2026, MetaQuotes Ltd.|
//|                           https://www.mql5.com/ru/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Christian Benjamin"
#property link      "https://www.mql5.com/ru/users/lynnchris"
#property version   "1.00"
#property strict
#property description "Blocks any trade on symbols not in the whitelist."

#include <SymbolWhitelist.mqh>

Инициализация - OnInit()

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

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   Print("SymbolWhitelistEnforcer started. AutoTrading must be enabled.");
   EventSetTimer(1);
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   EventKillTimer();
   Print("SymbolWhitelistEnforcer stopped.");
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Timer function (not strictly needed)                             |
//+------------------------------------------------------------------+
void OnTimer()
  {
   //--- Nothing to do here
  }
//+------------------------------------------------------------------+

Обработка торговых событий - OnTradeTransaction()

//+------------------------------------------------------------------+
//| Trade transaction handler - block disallowed symbols             | 
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
  {
   string symbol = "";
   ulong ticket = 0;
   bool isManual = false;

   if(trans.type == TRADE_TRANSACTION_ORDER_ADD)
     {
      ticket = trans.order;
      if(ticket == 0)
         return;
      if(!OrderSelect(ticket))
        {
         Print("Failed to select order ", ticket);
         return;
        }
      symbol = OrderGetString(ORDER_SYMBOL);
      isManual = (OrderGetInteger(ORDER_MAGIC) == 0);
     }
   else
      if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
        {
         ticket = trans.deal;
         if(ticket == 0)
            return;
         if(HistoryDealSelect(ticket))
           {
            symbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
            long magic = HistoryDealGetInteger(ticket, DEAL_MAGIC);
            isManual = (magic == 0);
           }
        }
      else
         return;

   if(symbol == "")
      return;

   if(!SWL::IsSymbolAllowed(symbol))
     {
      string source = isManual ? "manual" : "EA";
      Print("Blocking ", source, " trade on disallowed symbol: ", symbol);
      SWL::LogBlockedAttempt(TimeCurrent(), symbol, source);

      if(trans.type == TRADE_TRANSACTION_ORDER_ADD)
        {
         MqlTradeRequest req = {};
         MqlTradeResult  res = {};
         req.action   = TRADE_ACTION_REMOVE;
         req.order    = ticket;
         req.comment  = "Symbol not whitelisted";
         if(!OrderSend(req, res))
            Print("Failed to cancel order ", ticket, ": ", res.comment);
        }
      else
         if(trans.type == TRADE_TRANSACTION_DEAL_ADD)
           {
            ulong posTicket = HistoryDealGetInteger(ticket, DEAL_POSITION_ID);
            if(posTicket == 0)
               return;
            if(!PositionSelectByTicket(posTicket))
              {
               Print("Position ", posTicket, " not found.");
               return;
              }

            MqlTradeRequest req = {};
            MqlTradeResult  res = {};
            req.action    = TRADE_ACTION_DEAL;
            req.position  = posTicket;
            req.symbol    = symbol;
            req.volume    = PositionGetDouble(POSITION_VOLUME);
            req.deviation = 5;
            req.comment   = "Symbol not whitelisted";

            if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
              {
               req.price = SymbolInfoDouble(symbol, SYMBOL_BID);
               req.type  = ORDER_TYPE_SELL;
              }
            else
              {
               req.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
               req.type  = ORDER_TYPE_BUY;
              }
            if(!OrderSend(req, res))
               Print("Failed to close position ", posTicket, ": ", res.comment);
           }
     }
  }
//+------------------------------------------------------------------+

Советник выполняет мониторинг TRADE_TRANSACTION_ORDER_ADD и TRADE_TRANSACTION_DEAL_ADD. Для каждого события он извлекает символ, проверяет его с помощью SWL::IsSymbolAllowed() и реагирует соответствующим образом. Такой подход, основанный на событиях, обеспечивает немедленное принудительное применение правил, создавая надежную защиту от импульсивных торговых решений.

Идентификация источника сделки - Магическое число

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

Блокировка запрещенных сделок - немедленные действия

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

Практический рабочий процесс

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

Тестирование и результаты

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

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

Следующие диаграммы показывают работу системы, выделяя случаи, когда разрешенные символы были корректно идентифицированы и помечены как “РАЗРЕШЕНО“, а запрещенные символы были немедленно помечены как “ЗАБЛОКИРОВАНО”. Результаты показывают, что система надежно различает разрешенные и неразрешенные инструменты, обеспечивая прочную основу для полного контроля над сделками.

Разрешено

Заблокировано

Проверка разрешения и блокировки сделок

Наиболее важным тестом для системы была проверка ее способности выполнять две основные функции: (1) разрешение сделок только с символами из белого списка и (2) блокирование сделок с символами, не включенными в белый список.

На схеме ниже показаны все попытки совершения сделок. Сделки, совершенные с одобренными символами из белого списка, проходят в обычном режиме, в то время как попытки с символами, не включенными в белый список, перехватываются и блокируются советником-принудителем. Каждая попытка совершения сделки — разрешенная или заблокированная — представлена, что дает полное представление о работе системы.

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

Заключение

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

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

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

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

Вложения:

Название файла	Описание
SymbolWhitelist.mqh	Основной движок/общий подключаемый файл. Содержит всю центральную логику управления белым списком (SaveWhitelist, LoadWhitelist, ParseWhitelist), проверки символов (IsSymbolAllowed) и функции логирования/аудита (LogBlockedAttempt, ReadLog). Служит в качестве единого источника достоверной информации для системы.
SymbolWhitelistDashboard.mq5	Индикатор дашборда. Обеспечивает управление конфигурацией и наглядное отображение состояния в реальном времени. Принимает входные данные белого списка, сохраняет их в файл и отображает структурированную панель, показывающую утвержденные символы, текущий статус авторизации графика, недавние заблокированные попытки и статус контроля. Обновляется посредством односекундного таймера.
SymbolWhitelistEnforcer.mq5	Советник-принудитель. Действует как активный уровень управления, который отслеживает торговые транзакции (OnTradeTransaction). Отслеживает новые отложенные ордера и исполненные сделки, проверяет символы на соответствие белому списку и автоматически отменяет или закрывает любую сделку с неавторизованными символами. Логирует все заблокированные торговые попытки.

Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/21493

Прикрепленные файлы |

Загрузить ZIP

SymbolWhitelist.mqh (5.49 KB)

SymbolWhitelistDashboard.mq5 (14.67 KB)

SymbolWhitelistEnforcer.mq5 (5.03 KB)

Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.

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

Christian Benjamin

Developer, Trader and Pastor в Out For Christ Ministries International
Зимбабве
21233

Excellence and integrity define my approach to every project. The same standard is maintained regardless of compensation structure, guided by the conviction that God’s reward surpasses what man can offer. This principle shapes every tool I develop.

Другие статьи автора

Перейти к обсуждению на форуме трейдеров

От начального до среднего уровня: Словно мыльные пузыри

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

Создание пользовательских индикаторов в MQL5 (Часть 2): Разработка индикатора RSI в виде шкалы со стрелкой на Canvas

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

Особенности написания экспертов

Написание и тестирование экспертов в торговой системе MetaTrader 4.

Реализация модели гауссовской смеси в MQL5

В статье рассматриваются теоретические основы и практическая реализация модели смеси нормальных распределений (Gaussian Mixture Model) на языке MQL5. Представлен класс CGMM и примеры его использования, а также методология выбора оптимального количества компонентов модели с помощью информационных критериев AIC/BIC. Значительное внимание уделяется принципу работы EM-алгоритма — признанного стандарта при обучении вероятностных моделей со скрытыми(латентными) переменными. Реализована поддержка режима обучения MAP и инициализация параметров с помощью K-Means++. Готовый инструмент для кластеризации, оценки многомерной плотности и генерации данных теперь доступен и в MetaTrader 5.