Интерактивное управление зонами спроса и предложения на MQL5 (Часть V): Сохранение состояния зон между перезапусками терминала и советника
Введение
В части IV мы расширили возможности интерактивного менеджера зон спроса и предложения за пределы обнаружения зон и отслеживания их жизненного цикла, подключив проверенные зоны спроса и предложения к торговому слою. Теперь программная платформа могла оценивать взаимодействия с зонами и использовать их в автоматизированном торговом процессе.
После перезапуска советника или торгового терминала механизм обработки зон в прежнем виде мог вновь обнаруживать прямоугольники на графике, но терял все накопленное во время работы состояние: состояние жизненного цикла (нетронутая/пробитая/неактивная), историю взаимодействий и число касаний, оценки и распределение по уровням, флаги срабатывания сигналов покупки/продажи, записи черного списка, а также управляемую геометрию зон, нарисованных пользователем. На практике это приводит к тому, что восстановленные зоны ведут себя как новые; возможные последствия — повторные или неуместные входы в рынок, неверная фильтрация, рассогласование отображения и логики, а также необходимость заново рисовать или настраивать прямоугольники, созданные вручную.
В части V эта проблема решается добавлением слоя долговременного хранения, который записывает логическое состояние механизма обработки зон для каждого торгового контекста (торговый инструмент + таймфрейм). Архитектура долговременного хранения намеренно отделяет поведение во время выполнения от долговременно сохраняемого состояния: SZonePersist представляет собой снимок состояния в виде простых данных, содержащий идентификационные данные, геометрию, временные параметры, оценки и телеметрию, флаги жизненного цикла и временные точки привязки пользовательских зон; CZone по-прежнему отвечает за обнаружение зон, оценку их жизненного цикла и торговлю. При вызове OnInit() программная платформа восстанавливает сохраненные свойства зон и флаги жизненного цикла, согласует соответствующие графические объекты с восстановленным состоянием и выполняет существующие проверки актуальности при запуске. Долговременное хранение остается независимым от обнаружения зон и исполнения торговых операций.
Примечание: В части V поддерживается восстановление состояния зон после штатного завершения работы и перезапуска при наличии пригодного снимка состояния; при этом не реализована транзакционная запись с устойчивостью к аварийному завершению и не восстанавливается полное состояние торгового механизма.
Архитектурные приоритеты данного этапа
Цель состоит в том, чтобы сохранять логическое состояние механизма обработки зон независимо от времени существования процесса советника.
Таким образом, на данном этапе основное внимание уделяется четырем направлениям:
- Сохранение состояния зон, чтобы активные зоны можно было восстановить после перезапуска.
- Восстановление состояния жизненного цикла и взаимодействий вместо обработки восстановленных зон как вновь обнаруженных структур.
- Согласование графических объектов с сохраненным состоянием, включая восстановление ценовых границ зон, нарисованных пользователем, и их левых временных точек привязки с сохранением принятой в программной платформе политики продления правой границы.
- Регистрация зон, нарисованных пользователем, в управляемой коллекции с начальной базовой оценкой, чтобы их можно было оценивать в рамках существующего торгового конвейера.
Для этого мы добавляем слой долговременного хранения поверх существующего механизма обработки зон, что позволяет программной платформе сохранять свое состояние, не меняя распределения обязанностей по обнаружению зон, управлению их жизненным циклом и торговле.
Проектирование снимка состояния для долговременного хранения
Прежде чем реализовать процесс сохранения и восстановления, в программной платформе необходимо определить представление состояния зоны, которое может существовать независимо от объекта CZone, используемого во время выполнения.
Слой долговременного хранения вводит SZonePersist — структуру простых данных, содержащую информацию, необходимую для восстановления логической зоны после перезапуска советника. Это разделение сделано намеренно. Модулю долговременного хранения не нужно знать, как CZone выполняет обнаружение зон, оценку их жизненного цикла, торговые операции или отрисовку на графике. Ему нужно лишь сохранить состояние, необходимое для последующего восстановления зоны.
//+------------------------------------------------------------------+ //| SZonePersist: Plain-data snapshot of ONE logical zone | //| (decoupled from the CZone runtime class so this module never | //| needs to "understand" the lifecycle engine). | //+------------------------------------------------------------------+ struct SZonePersist { //--- Identity / Provenance string name; // Stable chart-object / zone identifier int zone_type; // ENUM_ZONE_TYPE (Support/Resistance/Neutral) int zone_status; // ENUM_ZONE_STATUS (Virgin/Broken/Inactive) bool is_user_zone; // AUTO or USER provenance //--- Geometry double top; double bottom; //--- Timing datetime created; // exact generation timestamp datetime last_touch_time; // last price test interaction datetime broken_time; // breakout confirmation stamp //--- Score int zone_score; // static structural weight score double current_zone_score; // LIVE score used by trading gate string zone_tier; // categorized tier label //--- Telemetry double initial_volume_ratio; double departure_velocity; int touch_count; int bounce_count; int failure_count; double max_reaction_pips; int resurrection_count; string breakout_quality; //--- Lifecycle flags (affect next state transition) bool is_pending; bool is_broken; int consecutive_closes_outside; int consecutive_rejection_closes; bool buy_triggered; bool sell_triggered; //--- Part V Stored time anchors (USER left anchor and managed right edge) datetime time_left; // OBJPROP_TIME 0 (left edge of the rectangle the user drew) datetime time_right; // Stored right anchor (0 = unspecified; use current time on restoration) };
Структура объединяет состояние, необходимое для восстановления зоны, в четыре группы: идентификационные данные и происхождение, геометрия и временные параметры, оценка и телеметрия, а также состояние жизненного цикла. При этом сохраняется не только информация о местоположении зоны, но и данные, накопленные за весь период ее существования. Для зон, нарисованных пользователем, сохраняются левая временная точка привязки и правая временная точка привязки, заданная программной платформой. При регистрации и ручном изменении зоны ее правая граница устанавливается на текущее время, а при отрисовке во время работы программы продолжает сдвигаться вправо; исходная конечная длина нарисованной зоны не сохраняется. Служебные свойства отрисовки, не предназначенные для долговременного хранения, намеренно не включаются в снимок состояния. Они относятся к слою отображения на графике и могут быть воссозданы на основе восстановленного логического состояния.
Это позволяет четко разграничить функции: SZonePersist хранит информацию о зоне и ее текущем состоянии, в то время как CZone по-прежнему отвечает за управление в процессе выполнения.
Определение пути долговременного хранения
Чтобы зона могла сохраняться после перезапуска советника или терминала, программной платформе прежде всего необходимо четко определенное место для хранения ее состояния.
Этим занимается функция SetupPersistencePath().
//+------------------------------------------------------------------+ //| Setup persistence folder and assign the state file path | //+------------------------------------------------------------------+ void SetupPersistencePath(void) { FolderCreate(ZP_FOLDER, FILE_COMMON); g_persist.SetPath(PersistFilePath()); }
Круг задач этой функции намеренно ограничен. Она подготавливает среду, необходимую слою долговременного хранения, но сама не выполняет сериализацию зон. Выделение этой обязанности означает, что остальным компонентам программной платформы не нужно знать, как подготавливается место хранения.
Это важно, поскольку долговременное хранение не входит в процесс обнаружения зон. Механизм обнаружения продолжает работать со своей коллекцией объектов CZone в оперативной памяти, а слой долговременного хранения предоставляет отдельный механизм для сохранения этого состояния между запусками.
После определения пути для долговременного хранения программная платформа должна установить, какой файл долговременного хранения относится к текущему контексту графика.
Эту задачу выполняет функция PersistFilePath(). Снимки состояния хранятся в папке Terminal\Common\Files\DynamicSR\V5. Для каждой пары «торговый инструмент — таймфрейм» предполагается только один экземпляр, записывающий данные в общее хранилище. Имя файла не обеспечивает разделения данных по торговым счетам, экземплярам советника и наборам параметров.
#define ZP_FOLDER "DynamicSR\\V5" // Folder under Terminal/Common/Files
//+------------------------------------------------------------------+ //| Part V Logical-state persistence helpers | //+------------------------------------------------------------------+ string PersistFilePath(void) { return ZP_FOLDER + "\\DSR5_" + _Symbol + "_" + IntegerToString(_Period) + ".bin"; }
Вместо использования единого глобального хранилища для долговременного хранения программная платформа формирует идентификатор файла на основе торгового контекста, в котором работает советник. Благодаря этому сохраненное состояние для одной пары «торговый инструмент — таймфрейм» остается отделенным от состояния для другой пары.
Например, состояние механизма обработки зон, работающего на одном торговом инструменте и таймфрейме, не должно случайно загружаться при подключении того же советника к графику с другим контекстом.
Благодаря этому слой долговременного хранения приобретает два важных свойства:
- Известное место хранения — заданное с помощью функции SetupPersistencePath().
- Зависящий от контекста идентификатор файла долговременного хранения — формируемый функцией PersistFilePath().
На данный момент ни одна зона еще не сохранена. Программная платформа пока лишь определила, где должно храниться состояние и как выбирается нужный снимок состояния.
Это разделение сделано намеренно. Следующий этап — определить, когда изменения текущего состояния зон требуют сохранения, и как отдельная зона из оперативной памяти преобразуется в форму, пригодную для хранения.
Обнаружение изменений состояния
После определения места долговременного хранения следующей задачей становится решение о том, когда именно состояние системы во время выполнения необходимо записать в хранилище.
Программная платформа решает эту задачу с помощью функции MarkPersistDirty().
//+------------------------------------------------------------------+ //| Mark persistence state for the next save cycle | //+------------------------------------------------------------------+ void MarkPersistDirty(void) { g_persist_dirty = true; }
Вместо того чтобы записывать все состояние зон на диск при каждом выполнении какой-либо части советника, программная платформа устанавливает флаг наличия изменений для состояния долговременного хранения, когда происходит изменение, которое впоследствии необходимо сохранить.
Это позволяет провести простое разграничение между двумя состояниями:
- Без изменений — сохраненный снимок состояния уже отражает текущее состояние.
- Есть изменения — состояние во время работы изменилось, и сохраненный снимок состояния может быть уже неактуален.
Сама по себе эта функция не выполняет сохранение. Она лишь отмечает, что изменения состояния нужно сохранить. Такое разделение полезно, поскольку состояние зоны может изменяться в ходе обычной обработки во время выполнения. Зона может переходить от одного этапа жизненного цикла к другому, накапливать сведения о взаимодействиях, менять свою оценку или иным образом получать информацию, которую необходимо сохранить, чтобы она не была утрачена при перезапуске. Компоненту, обнаруживающему это изменение, не требуется немедленно выполнять операции с файлами.
Вместо этого он передает сигнал слою долговременного хранения.
Поэтому следующий шаг — определить, какие именно данные объекта CZone, используемого во время работы, необходимо сохранить.
Это преобразование осуществляется функцией PersistZoneToRecord().
//+------------------------------------------------------------------+ //| Copy runtime zone state into a persistence record | //+------------------------------------------------------------------+ void PersistZoneToRecord(const CZone *z, SZonePersist &r) { r.name = z.name; r.zone_type = (int)z.type; r.zone_status = (int)z.status; r.is_user_zone = z.is_user_zone; r.top = z.top; r.bottom = z.bottom; r.created = z.created; r.last_touch_time = z.last_touch_time; r.broken_time = z.broken_time; r.zone_score = z.zone_score; r.current_zone_score = z.Current_zone_score; r.zone_tier = z.zone_tier; r.initial_volume_ratio = z.initial_volume_ratio; r.departure_velocity = z.departure_velocity; r.touch_count = z.touch_count; r.bounce_count = z.bounce_count; r.failure_count = z.failure_count; r.max_reaction_pips = z.max_reaction_pips; r.resurrection_count = z.resurrection_count; r.breakout_quality = z.breakout_quality; r.is_pending = z.is_pending; r.is_broken = z.is_broken; r.consecutive_closes_outside = z.consecutive_closes_outside; r.consecutive_rejection_closes = z.consecutive_rejection_closes; r.buy_triggered = z.buy_triggered; r.sell_triggered = z.sell_triggered; r.time_left = z.time_left; // Part V real time anchors r.time_right = z.time_right; }
Здесь программная платформа переходит от обнаружения изменений к представлению состояния.
Существующий в памяти объект CZone содержит данные, используемые механизмом обработки зон во время работы, однако слой долговременного хранения не должен пытаться просто сохранить весь этот объект как есть. Вместо этого необходимые данные состояния преобразуются в запись долговременного хранения, содержащую информацию для последующего восстановления зоны.
Это создает границу между двумя представлениями: Объект CZone в памяти → запись долговременного хранения.
Объект в памяти по-прежнему отвечает за поведение зоны, а запись долговременного хранения обеспечивает стабильное представление информации, которая должна сохраняться после завершения работы экземпляра советника.
Теперь, когда изменения можно выявлять, а отдельные зоны — преобразовывать в записи долговременного хранения, у программной платформы есть все необходимые компоненты для создания полного снимка состояния.
Создание и сохранение снимка состояния зон
Когда программная платформа определяет, что состояние необходимо сохранить, и может преобразовать отдельный объект CZone в запись долговременного хранения, она может сформировать полное представление текущего состояния механизма обработки зон.
Этим занимается функция SavePersistState().
//+------------------------------------------------------------------+ //| Save the current zone and blacklist state | //+------------------------------------------------------------------+ void SavePersistState(void) { SZonePersist records[]; int n = active_zones.Total(); if(n <= 0) ArrayResize(records, 0); else { ArrayResize(records, n); int fill = 0; for(int i = 0; i < n; i++) { CZone *z = (CZone*)active_zones.At(i); if(z == NULL) continue; PersistZoneToRecord(z, records[fill]); fill++; } ArrayResize(records, fill); } double blk[]; int bc = blacklist.Total(); if(bc <= 0) ArrayResize(blk, 0); else { ArrayResize(blk, bc); for(int i = 0; i < bc; i++) blk[i] = StringToDouble(blacklist.At(i)); } g_persist_dirty = !g_persist.SaveSnapshot(records, blk); }
Функция SavePersistState() работает на уровне коллекции зон, а не отдельной зоны. Она использует текущее состояние, поддерживаемое программной платформой во время работы, и формирует набор записей долговременного хранения, которые будут представлять это состояние после перезапуска. Флаг наличия изменений сбрасывается только в том случае, если функция SaveSnapshot() возвращает значение true. Если функция SaveSnapshot() сообщает о неудаче, флаг наличия изменений остается установленным для повторной попытки, в том числе при запуске.
Таким образом, этот процесс можно представить следующим образом: коллекция зон во время работы → записи долговременного хранения → снимок состояния.
Именно здесь становится полезным введенное ранее разделение объектов, используемых во время работы, и данных для долговременного хранения. Процедуре долговременного хранения не требуется воспроизводить внутреннее поведение объекта CZone; ей достаточно собрать данные о состоянии, которые программная платформа явно определила как подлежащие долговременному хранению.
После формирования снимка состояния сама операция сохранения передается компоненту долговременного хранения.
Эта ответственность возлагается на функцию CZonePersistence::SaveSnapshot().
//+------------------------------------------------------------------+ //| CZonePersistence::SaveSnapshot | //| Binary layout: | //| Header : MAGIC(int) | FORMAT_VERSION(int) | //| Zones : count(int) { SZonePersist record }*count | //| Blacklist: count(int) | double price*count | //| FileFlush() flushes buffered writes; this is not an atomic save. | //| This represents CURRENT logical state (deleted zones ARE NOT | //| present here - the caller only feeds what is logically alive). | //+------------------------------------------------------------------+ bool CZonePersistence::SaveSnapshot(SZonePersist &zones[],double &blacklist_prices[]) { if(m_path == "") return false; int h = FileOpen(m_path,FILE_WRITE|FILE_BIN|FILE_COMMON); if(h == INVALID_HANDLE) { PrintFormat("[Part V][PERSIST] Save failed. FileOpen error: %d",GetLastError()); return false; } //--- Header FileWriteInteger(h,(int)ZP_MAGIC,INT_VALUE); FileWriteInteger(h,ZP_FORMAT_VERSION,INT_VALUE); //--- Zones int zc = ArraySize(zones); FileWriteInteger(h,zc,INT_VALUE); for(int i=0;i<zc;i++) WriteZone(h,zones[i]); //--- Blacklist int bc = ArraySize(blacklist_prices); FileWriteInteger(h,bc,INT_VALUE); for(int i=0;i<bc;i++) FileWriteDouble(h,blacklist_prices[i]); FileFlush(h); // flush buffered writes FileClose(h); return true; }
Эта функция образует границу между механизмом обработки зон и механизмом хранения.
Менеджер зон знает, какое состояние необходимо сохранить. CZonePersistence знает, как это состояние записывается в постоянное хранилище. Благодаря этому детали работы с файлами остаются за пределами логики управления зонами, а механизм долговременного хранения остается независимым от обнаружения зон и обработки их жизненного цикла.
Примечание по архитектуре: долговременное хранение и устойчивость к аварийному завершению
Функция FileFlush() сбрасывает буферизованные данные в файл, но не обеспечивает атомарную замену снимка состояния. В настоящее время функция SaveSnapshot() напрямую записывает один файл состояния с сигнатурой и версией формата для проверки, но без резервной копии, контрольной суммы или замены основного файла временным.
Реализация из части V сохраняет состояние при штатных перезапусках советника и терминала; она не обеспечивает транзакционное восстановление после сбоя. Сбой или завершение работы во время записи может привести к появлению неполного снимка состояния. Загрузчик отклоняет файлы, не прошедшие проверки формата, полноты или значений, и запуск продолжается без восстановления этого снимка состояния. Без контрольной суммы эти проверки не позволяют выявить все возможные виды повреждений.
То же различие относится и к механизму отслеживания несохраненных изменений: изменения сохраняются в ходе обычного цикла работы и при штатной деинициализации, однако принудительное завершение может произойти до того, как последнее изменение попадет в хранилище.
Это намеренное ограничение объема задач, рассматриваемых в части V. Слой долговременного хранения поддерживает восстановление после штатного перезапуска; для транзакционного долговременного хранения с устойчивостью к аварийному завершению потребовались бы дополнительные механизмы, такие как атомарная замена или резервные снимки состояния.
Загрузка сохраненного снимка состояния
Сохранение снимка состояния дает программной платформе долговременно хранимое представление состояния ее зон, однако долговременное хранение полезно лишь в том случае, если эти данные можно восстановить при повторном запуске советника.
Процесс восстановления начинается с вызова функции LoadPersistState().
//+------------------------------------------------------------------+ //| Restore persisted zones and blacklist state | //+------------------------------------------------------------------+ void LoadPersistState(void) { active_zones.Clear(); blacklist.Clear(); SZonePersist records[]; double blk[]; int version = g_persist.LoadSnapshot(records, blk); if(version < 0) { PrintFormat("[Part V][PERSIST] No usable snapshot (code %d). Starting fresh.", version); return; } int bc = ArraySize(blk); for(int i = 0; i < bc; i++) blacklist.Add(DoubleToString(blk[i], _Digits)); int n = ArraySize(records); for(int i = 0; i < n; i++) { CZone *z = RebuildZoneFromRecord(records[i]); if(z != NULL) active_zones.Add(z); } PrintFormat("[Part V][PERSIST] Restored %d zones / %d blacklist entries (format v%d).", active_zones.Total(), blacklist.Total(), version); }
В отличие от сохранения, при котором исходными данными служат объекты в памяти работающей программы, загрузка начинается с сохраненного представления. Функция запрашивает ранее сохраненный снимок состояния и использует его как источник данных для восстановления логического состояния программной платформы.
Непосредственное чтение файла и десериализация по-прежнему выполняются внутри компонента долговременного хранения методом CZonePersistence::LoadSnapshot().
//+------------------------------------------------------------------+ //| CZonePersistence::LoadSnapshot | //| Returns FORMAT_VERSION on success, or a negative code: | //| -1 no file / open error | //| -2 invalid/incomplete data or allocation failure | //| -3 unsupported format version | //| On success fills zones[] and blacklist_prices[] (resized). | //+------------------------------------------------------------------+ int CZonePersistence::LoadSnapshot(SZonePersist &zones[],double &blacklist_prices[]) { ResetLastError(); m_read_error = false; ArrayResize(zones,0); ArrayResize(blacklist_prices,0); if(m_path == "") return -1; int h = FileOpen(m_path,FILE_READ|FILE_BIN|FILE_COMMON); if(h == INVALID_HANDLE) return -1; if(FileSize(h) < 16) { FileClose(h); return -2; } //--- Header int magic = FileReadInteger(h,INT_VALUE); if(GetLastError() != 0 || magic != (int)ZP_MAGIC) { FileClose(h); return -2; } int version = FileReadInteger(h,INT_VALUE); if(GetLastError() != 0) { FileClose(h); return -2; } if(version < 1 || version > ZP_FORMAT_VERSION) { FileClose(h); return -3; } //--- Part V version 1 files read via legacy layout (time anchors defaulted); newer versions via version field //--- Zones int zc = FileReadInteger(h,INT_VALUE); if(GetLastError() != 0 || zc < 0 || zc > 100000) { FileClose(h); return -2; } if(ArrayResize(zones,zc) != zc) { FileClose(h); ArrayResize(zones,0); return -2; } for(int i=0;i<zc;i++) { if(!ReadZone(h,zones[i],version)) { FileClose(h); ArrayResize(zones,0); return -2; } } //--- Blacklist if(FileTell(h) > FileSize(h) || FileSize(h) - FileTell(h) < 4) { FileClose(h); ArrayResize(zones,0); return -2; } ResetLastError(); int bc = FileReadInteger(h,INT_VALUE); if(GetLastError() != 0 || bc < 0 || bc > 100000) { FileClose(h); ArrayResize(zones,0); return -2; } if(FileTell(h) > FileSize(h) || FileSize(h) - FileTell(h) != (ulong)bc * 8) { FileClose(h); ArrayResize(zones,0); return -2; } if(ArrayResize(blacklist_prices,bc) != bc) { FileClose(h); ArrayResize(zones,0); ArrayResize(blacklist_prices,0); return -2; } for(int i=0;i<bc;i++) { ResetLastError(); blacklist_prices[i] = FileReadDouble(h); if(GetLastError() != 0 || !MathIsValidNumber(blacklist_prices[i])) { FileClose(h); ArrayResize(zones,0); ArrayResize(blacklist_prices,0); return -2; } } FileClose(h); return version; }
Функция LoadSnapshot() проверяет, поддерживается ли версия формата, а также проверяет данные черного списка. Вспомогательные функции ReadString() и ReadZone() в прилагаемом исходном коде проверяют длину строк и полноту записей, а также выполняют базовые проверки значений параметров зон. При обнаружении ошибки функция возвращает отрицательный код и очищает выходные массивы. Эти проверки обеспечивают базовую проверку корректности данных, а не проверку целостности на основе контрольных сумм.
Благодаря этому формат хранения остается отделенным от механизма обработки зон. Функция LoadSnapshot() отвечает за чтение сохраненных данных и предоставление их вызывающему коду; к ее задачам также относятся работа с форматом долговременного хранения, связанные с ним проверки корректности и обработка версий.
Затем функция LoadPersistState() использует эти записи для восстановления состояния, необходимого механизму обработки зон во время работы.
Это различие важно, поскольку загрузка записи — не то же самое, что воссоздание объекта зоны в памяти работающей программы. Слой долговременного хранения может восстановить сохраненные данные, но механизму обработки зон по-прежнему нужен полноценный объект CZone, который можно обрабатывать в рамках жизненного цикла и обновлять в дальнейшем.
Это преобразование осуществляется функцией RebuildZoneFromRecord().
//+------------------------------------------------------------------+ //| Rebuild a runtime zone from its persisted state | //+------------------------------------------------------------------+ CZone* RebuildZoneFromRecord(const SZonePersist &r) { CZone *z = new CZone((r.top + r.bottom) / 2.0, (ENUM_ZONE_TYPE)r.zone_type, r.created, g_cached_atr); if(z == NULL) return NULL; z.name = r.name; z.is_user_zone= r.is_user_zone; z.top = r.top; z.bottom = r.bottom; z.price_level = (r.top + r.bottom) / 2.0; z.height = r.top - r.bottom; z.created = r.created; z.last_touch_time = r.last_touch_time; z.broken_time = r.broken_time; z.status = (ENUM_ZONE_STATUS)r.zone_status; z.is_broken = r.is_broken; z.is_pending = r.is_pending; z.consecutive_closes_outside = r.consecutive_closes_outside; z.consecutive_rejection_closes = r.consecutive_rejection_closes; z.buy_triggered = r.buy_triggered; z.sell_triggered = r.sell_triggered; z.time_left = r.time_left; // Part V real time anchors z.time_right = r.time_right; z.zone_score = r.zone_score; z.Current_zone_score = r.current_zone_score; z.zone_tier = r.zone_tier; z.initial_volume_ratio = r.initial_volume_ratio; z.departure_velocity = r.departure_velocity; z.touch_count = r.touch_count; z.bounce_count = r.bounce_count; z.failure_count = r.failure_count; z.max_reaction_pips = r.max_reaction_pips; z.resurrection_count = r.resurrection_count; z.breakout_quality = r.breakout_quality; z.was_drawn = false; return z; }
Функция RebuildZoneFromRecord() принимает сохраненное представление и на его основе воссоздает объект зоны в памяти работающей программы. Восстановленный объект не рассматривается как вновь обнаруженная зона. Его сохраненные свойства и флаги жизненного цикла восстанавливаются, а не инициализируются, как в случае с вновь обнаруженной зоной. Восстановленная коллекция по-прежнему подлежит проверкам актуальности при запуске.
На данном этапе логическое состояние зон восстановлено. Однако до завершения восстановления программная платформа должна решить еще одну задачу: привести сам график в соответствие с восстановленным состоянием.
Согласование восстановленных зон с графиком
Восстановление логического состояния зоны не приводит к автоматическому восстановлению графического объекта, который ее представляет.
Поэтому программная платформа выполняет этап согласования с помощью ReconcileChartObjects().
//+------------------------------------------------------------------+ //| Reconcile persisted zones with chart objects | //+------------------------------------------------------------------+ void ReconcileChartObjects(void) { //--- 1. Ensure every restored zone has a chart object (recreate if missing) for(int i = 0; i < active_zones.Total(); i++) { CZone *z = (CZone*)active_zones.At(i); if(z == NULL) continue; if(ObjectFind(0, z.name) < 0) { if(ObjectCreate(0, z.name, OBJ_RECTANGLE, 0, (z.time_left != 0) ? z.time_left : z.created, z.top, (z.time_right != 0) ? z.time_right : TimeCurrent(), z.bottom)) // Part V restore stored anchors (right edge remains framework-managed) { ObjectSetInteger(0, z.name, OBJPROP_BACK, true); ObjectSetInteger(0, z.name, OBJPROP_RAY_RIGHT, true); ObjectSetInteger(0, z.name, OBJPROP_SELECTABLE, true); ObjectSetInteger(0, z.name, OBJPROP_FILL, !z.is_broken); ObjectSetString(0, z.name, OBJPROP_TEXT, z.is_user_zone ? "USER" : "AUTO"); z.was_drawn = true; } } else { ObjectSetDouble(0, z.name, OBJPROP_PRICE, 0, z.top); ObjectSetDouble(0, z.name, OBJPROP_PRICE, 1, z.bottom); z.was_drawn = true; } ObjectSetInteger(0, z.name, OBJPROP_COLOR, z.GetColor()); //--- Part V apply persisted time anchors to the chart object ObjectSetInteger(0, z.name, OBJPROP_TIME, 0, (z.time_left != 0) ? z.time_left : z.created); ObjectSetInteger(0, z.name, OBJPROP_TIME, 1, (z.time_right != 0) ? z.time_right : TimeCurrent()); } //--- 2. Discover orphan USER rectangles with no persisted state -> normal USER birth path int total_objects = ObjectsTotal(0); for(int o = total_objects - 1; o >= 0; o--) { string oname = ObjectName(0, o); if(ObjectGetInteger(0, oname, OBJPROP_TYPE) != OBJ_RECTANGLE) continue; if(GetZoneByName(oname) != NULL) continue; if(StringSubstr(oname, 0, 2) == "S_" || StringSubstr(oname, 0, 2) == "R_") { ObjectDelete(0, oname); continue; } if(RegisterUserZone(oname)) MarkPersistDirty(); } }
Задача этой функции — сравнить восстановленное состояние зон с объектами, присутствующими в данный момент на графике, и вновь привести визуальный слой в соответствие с текущим состоянием в памяти.
Это особенно важно при перезапусках терминала и советника. Объект CZone, восстановленный из данных долговременного хранения, существует в памяти, тогда как соответствующий ему прямоугольник может уже отсутствовать на графике. В такой ситуации при согласовании воссоздается отсутствующее графическое представление зоны на основе сохраненных сведений о ней.
Для зон, нарисованных пользователем, при согласовании восстанавливаются сохраненные ценовые границы и левая временная точка привязки. Правая граница остается под управлением программной платформы и продолжает сдвигаться вправо во время работы. Графический объект представляет зону, но не является источником данных о состоянии ее жизненного цикла. Сохраненное состояние механизма остается источником достоверных данных, а ReconcileChartObjects() восстанавливает визуальное представление, необходимое для отражения этого состояния.
Это также позволяет программной платформе обрабатывать случаи, когда состояние графика изначально не соответствует состоянию долговременного хранения. Объект может отсутствовать, уже присутствовать или требовать синхронизации своих визуальных свойств с восстановленным состоянием зоны.
Таким образом, последовательность запуска можно рассматривать как два взаимосвязанных процесса восстановления:
- Логическое восстановление
Сохраненный снимок состояния → CZone
- Визуальное согласование
CZone → графический объект
Такое разделение не позволяет графику стать вторым, конкурирующим источником достоверной информации о состоянии зоны.
Для восстановленных зон вновь доступны сохраненное состояние жизненного цикла и графическое представление. Зоны, оставшиеся после последующей проверки актуальности при запуске, затем переходят к обычной обработке во время работы.
Включение зон, нарисованных пользователем, в управляемый конвейер
Зоны, нарисованные пользователем, уже поддерживались на предыдущих этапах разработки программной платформы. В части IV было установлено, что к автоматической торговле допускаются только зоны с оценкой не ниже MinZoneScore. В части V сохраняется порог оценки для допуска к торговле, а вновь зарегистрированным пользовательским прямоугольникам присваивается начальная базовая оценка MinZoneScore; автоматическая оценка кандидатов для них не проводится.
//+------------------------------------------------------------------+ //| Registers a Raw Manual User Box into a Tracked Engine Object | //+------------------------------------------------------------------+ bool RegisterUserZone(string obj_name) { if(ObjectFind(0, obj_name) < 0 || GetZoneByName(obj_name) != NULL) // Part V duplicate guard: skip already-restored/registered (stops per-restart growth) return false; double boundary_p1 = ObjectGetDouble(0, obj_name, OBJPROP_PRICE, 0); double boundary_p2 = ObjectGetDouble(0, obj_name, OBJPROP_PRICE, 1); double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID); //--- Get current volatility context safely from structural global state double passed_atr = g_cached_atr; ENUM_ZONE_TYPE derived_type = ((boundary_p1 + boundary_p2) / 2.0 > bid) ? ZONE_RESISTANCE : ZONE_SUPPORT; CZone* new_zone = new CZone((boundary_p1 + boundary_p2) / 2.0, derived_type, TimeCurrent(), passed_atr); new_zone.name = obj_name; new_zone.is_user_zone = true; new_zone.was_recently_moved = true; new_zone.top = MathMax(boundary_p1, boundary_p2); new_zone.bottom = MathMin(boundary_p1, boundary_p2); new_zone.height = new_zone.top - new_zone.bottom; new_zone.price_level = (new_zone.top + new_zone.bottom) / 2.0; new_zone.was_drawn = true; //--- Part V USER birth score: manual drawing is the hypothesis assign MinZoneScore new_zone.zone_score = MinZoneScore; new_zone.Current_zone_score = MinZoneScore; if(MinZoneScore >= 95) new_zone.zone_tier = "ELITE"; else if(MinZoneScore >= 80) new_zone.zone_tier = "HIGH"; else if(MinZoneScore >= 50) new_zone.zone_tier = "MODERATE"; else new_zone.zone_tier = "LOW"; new_zone.time_left = (datetime)ObjectGetInteger(0, obj_name, OBJPROP_TIME, 0); // Part V real left anchor the user drew new_zone.time_right = TimeCurrent(); // Part V framework-managed right edge starts at current time ObjectSetInteger(0, obj_name, OBJPROP_TIME, 1, TimeCurrent()); ObjectSetString(0, obj_name, OBJPROP_TEXT, "USER"); ObjectSetInteger(0, obj_name, OBJPROP_RAY_RIGHT, true); ObjectSetInteger(0, obj_name, OBJPROP_BACK, true); ObjectSetInteger(0, obj_name, OBJPROP_FILL, true); ObjectSetInteger(0, obj_name, OBJPROP_COLOR, new_zone.GetColor()); active_zones.Add(new_zone); MarkPersistDirty(); // Part V newly registered USER zone must be persisted return true; }
Для прямоугольника, нарисованного пользователем, недостаточно данных обнаружения, чтобы рассчитать такую же структурную оценку, как для автоматически обнаруженной зоны. Вместо этого он включается в общий процесс обработки с начальной оценкой MinZoneScore.
Это обеспечивает зоне допустимую начальную оценку без создания отдельной схемы оценки или торговли. С этого момента зона управляется так же, как и любая другая зона. Таким образом, состояние ее жизненного цикла, взаимодействия, изменения оценки и флаги срабатывания сигналов покупки и продажи могут сохраняться вместе с соответствующими данными автоматически обнаруженных зон. В результате получается единый управляемый конвейер: пользователь задает зону, а программная платформа присваивает ей начальную базовую оценку и продолжает оценивать ее с помощью существующих механизмов жизненного цикла и торговли.
Интеграция долговременного хранения в жизненный цикл советника
Долговременное хранение интегрируется с советником через три основных обработчика событий его жизненного цикла: OnInit(), OnTick() и OnDeinit(). При запуске также удаляются зоны, которые больше не актуальны при текущей цене, поэтому число восстановленных зон может отличаться от итогового числа активных зон. Флаг инициализации обозначает завершение восстановления при запуске, а не подтверждение успешного завершения первоначального сохранения.
Инициализация: OnInit()
//+------------------------------------------------------------------+ //| Expert Initialization Function | //+------------------------------------------------------------------+ int OnInit(void) { //--- Part V Startup reconstruction: restore persisted + chart state, then detect only new zones //--- Part V keep existing rectangles during initialization for reconciliation active_zones.FreeMode(true); active_zones.Clear(); blacklist.Clear(); //--- Force MetaTrader core to stream visual object events ChartSetInteger(0, CHART_EVENT_OBJECT_CREATE, true); ChartSetInteger(0, CHART_EVENT_OBJECT_DELETE, true); atr_handle = iATR(_Symbol, _Period, 14); if(atr_handle == INVALID_HANDLE) { Print("[BOOT ERROR] Failed to instantiate core ATR indicator handle."); return(INIT_FAILED); } //--- Initial local data copy for startup procedures UpdateGlobalVolatilityCache(); // Sets g_cached_atr safely logger.Initialize(); //--- Part V Restore persisted logical state + reconcile chart BEFORE auto-detection, //--- so already-restored AUTO zones and blacklist remain authoritative in //--- future duplicate-suppression / creation guards. SetupPersistencePath(); LoadPersistState(); ReconcileChartObjects(); //--- Sync and find ONLY genuinely new dynamic zones (restored ones are deduplicated) DetectDynamicZones(g_cached_atr, true); // Pass true to perform deep historical boot scan on startup NukeIrrelevantZones(); //--- Part V Persist the reconciled baseline after startup reconstruction SavePersistState(); g_persist_loaded = true; //--- INITIALIZE THE TRADING ENGINE INFRASTRUCTURE COMPONENTS if(CheckTradingSignals) { g_trade = new CTradeManager(MagicNumber, LotSize, MaxSpreadPoints, UseTrailingStop, (int)TrailingStartPips, (int)TrailingStepPips); g_strategy = new CZoneStrategy(MinZoneScore, BounceConfirmCloses, RiskRewardRatio, ATRBufferMultiplier, InpUseHTFFilter, InpHtfTimeframe, InpHtfMaPeriod, InpUseHTFRsiFilter, // Enable HTF RSI Exhaustion Filter InpHtfRsiPeriod, // HTF RSI Period InpHtfRsiOverbought, // HTF RSI Overbought Threshold InpHtfRsiOversold, // HTF RSI Oversold Threshold InpApproachBars, InpApproachThreshold); } Print(">>> successfully initialized"); return(INIT_SUCCEEDED); }
При запуске сохраненное состояние восстанавливается, а его представление на графике согласуется с ним до начала поиска зон на исторических данных. Благодаря этому восстановленные зоны и записи черного списка сохраняют приоритет и не принимаются ошибочно за вновь обнаруженные зоны.
Работа советника: OnTick()//+------------------------------------------------------------------+ //| Expert Tick Function | //+------------------------------------------------------------------+ void OnTick(void) { datetime current_candle_time = iTime(_Symbol, _Period, 0); bool is_new_bar = (current_candle_time != last_bar_time); //--- Part V Flush any material state changes accumulated since the last tick if(g_persist_dirty) SavePersistState(); if(is_new_bar) { last_bar_time = current_candle_time; //--- Single point of entry update for data pipeline UpdateGlobalVolatilityCache(); //--- Downstream distribution using pristine global state context ResolvePendingInteractions(g_cached_atr); DetectDynamicZones(g_cached_atr, false); // Pass false to scan ONLY the single newly matured bar open MergeZones(g_cached_atr); //--- State Machine Lifecycle Evaluation Pipeline (Using MergeSensitivity) MonitorZoneLifecycle(logger, active_zones, g_cached_atr, MergeSensitivity); UpdateZoneVisuals(true); ChartRedraw(0); } else { //--- State Machine Lifecycle Evaluation Pipeline (Run on every tick to capture immediate manual adjustments) MonitorZoneLifecycle(logger, active_zones, g_cached_atr, MergeSensitivity); UpdateZoneVisuals(false); } //--- Tick-by-tick risk management and dynamic trailing updates if(CheckTradingSignals && CheckPointer(g_trade) != POINTER_INVALID) { g_trade.UpdateTrailingStop(_Symbol); } }
При нормальном выполнении порядок обработки зон остается прежним. Операции, изменяющие состояние, устанавливают флаг наличия изменений для долговременного хранения, а цикл сохранения при необходимости записывает текущее логическое состояние.
Таким образом, долговременное хранение дополняет существующий механизм обработки зон, не встраиваясь в логику их обнаружения или жизненного цикла
Завершение работы: OnDeinit()
//+------------------------------------------------------------------+ //| Expert Deinitialization Function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- Part V Final save attempt as an extra safeguard (not the sole persistence point) if(g_persist_loaded && g_persist_dirty) SavePersistState(); ObjectsDeleteAll(0, -1, OBJ_RECTANGLE); active_zones.Clear(); blacklist.Clear(); if(atr_handle != INVALID_HANDLE) { IndicatorRelease(atr_handle); atr_handle = INVALID_HANDLE; } //--- DEALLOCATE STRATEGY AND EXECUTION LAYER POINTERS SAFELY FROM MEMORY if(CheckPointer(g_trade) == POINTER_DYNAMIC) { delete g_trade; g_trade = NULL; } if(CheckPointer(g_strategy) == POINTER_DYNAMIC) { delete g_strategy; g_strategy = NULL; } PrintFormat(">>> Deinitialization Engine detached smoothly. Reason Code: %d", reason); ChartRedraw(); }
Функция OnDeinit() предоставляет последнюю возможность сохранить все оставшиеся несохраненные изменения перед завершением работы экземпляра советника. После последней попытки сохранения функция OnDeinit() намеренно удаляет с графика все объекты-прямоугольники, в том числе не связанные с советником. При следующем подключении советника управляемые зоны можно воссоздать из пригодного для восстановления снимка состояния; рисунки, не находящиеся под управлением советника, в этот снимок состояния не включаются.
Полученный жизненный цикл довольно прост:
- OnInit() — восстановление и согласование.
- OnTick() — обработка в обычном режиме и сохранение изменений.
- OnDeinit() — попытка сохранить оставшиеся несохраненные изменения.
Таким образом, долговременное хранение продлевает время жизни механизма обработки зон, не меняя распределения обязанностей между обнаружением зон, управлением их жизненным циклом и торговлей.
Пошаговое руководство по эксплуатации
Чтобы продемонстрировать долговременное хранение результатов удаления зон и черного списка между перезапусками, подключите советник к графику с уже существующими зонами и дайте ему создать начальный снимок состояния.

Рис. 1. Начальное состояние зон, отображаемое программной платформой
Затем намеренно удалите с графика одну или несколько автоматически созданных зон. Этот тест проверяет, отражается ли удаление зоны пользователем в управляемой коллекции, а затем и в сохраненном состоянии, вместо того чтобы зона воссоздавалась при следующем запуске. В прилагаемый исходный код включен обработчик события удаления графического объекта; он исключает удаленные зоны из управляемой коллекции, записывает цены исключения для зон AUTO и устанавливает флаг наличия изменений для долговременного хранения. Эти цены используются для подавления создания зон-кандидатов, находящихся поблизости, с учетом порога близости; они не служат для идентификации отдельных пивотов.
Снимите советник с графика и установите его снова. В журнале запуска должно отображаться актуальное количество восстановленных зон и записей в черном списке. В ходе нашего тестирования при первом перезапуске было восстановлено 7 зон и 2 записи в черном списке. После удаления зоны при следующем перезапуске было восстановлено 6 зон и 3 записи в черном списке. Мы повторили этот процесс еще раз, и при следующем перезапуске было восстановлено 5 зон и 4 записи в черном списке. Эта последовательность показывает, что результаты удаления зон AUTO и записи в черном списке сохраняются между циклами снятия советника с графика и его повторной установки.

Рис. 2. Количество восстановленных зон и записей в черном списке при перезапусках советника
Заключение
В части V завершается реализация еще одного важного слоя менеджера зон, позволяющего сохранять его логическое состояние после завершения работы отдельного экземпляра советника. Теперь программная платформа может сохранять управляемые зоны, флаги жизненного цикла, накопленные телеметрические данные, ценовые записи черного списка, а также ценовые границы и временные точки привязки зон, нарисованных пользователем. При перезапуске программная платформа восстанавливает пригодные для использования снимки состояния, выполняет согласование графических объектов и проводит существующую проверку актуальности при запуске перед началом обычной обработки.
Не менее важно и то, что долговременное хранение по-прежнему отделено от обнаружения зон, управления жизненным циклом и торговли. Долговременное хранение расширяет программную платформу, не меняя сфер ответственности систем, уже созданных в предыдущих частях. Теперь, когда механизм обработки зон способен сохранять свое состояние между сеансами, следующим шагом станет расширение набора источников этого состояния.
В следующей части мы сосредоточимся на создании зон на нескольких таймфреймах, что позволит программной платформе обнаруживать зоны и управлять ими на разных таймфреймах.
| Файл | Описание |
|---|---|
| MasterLog2.mqh | Модуль журналирования, предназначенный для повторного использования и применяемый советником. Он предоставляет необходимые проекту средства журналирования. |
| DynamicSR5.mq5 | Основной советник. Он демонстрирует механизм взаимодействия с динамическими уровнями поддержки и сопротивления, представленный в этой статье, и служит точкой входа для прилагаемого исходного кода. |
| TradeManager.mqh | Реализует слой исполнения торговых операций и управления позициями. Модуль отвечает за отправку, отслеживание и управление ордерами, сформированными стратегией, оставаясь независимым от процесса принятия решений. |
| ZoneStrategy.mqh | Реализует механизм принятия торговых решений. Модуль оценивает отобранные зоны спроса и предложения с помощью последовательности проверочных фильтров, после чего формирует торговые запросы и передает их менеджеру торговли для исполнения. |
| ZonePersistence.mqh | Обеспечивает хранение и восстановление логического состояния менеджера зон в двоичном формате с поддержкой версий. |
| MQL5.zip | Архив с корневой папкой MQL5, содержащий все перечисленные выше файлы. Распакуйте его в каталог установки терминала, чтобы файл DynamicSR5.mq5 оказался в папке MQL5\Experts\DynamicSR\V5\, а сопутствующие файлы .mqh — в папке MQL5\Include\DynamicSR\V5\. |
Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/24389
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.