Summary: Advanced deep dive into MQL4 event-driven architecture for professional EA development. Covers OnInit-OnDeinit lifecycle, tick processing optimization, timer implementation, and resource cleanup strategies with runnable code examples.
MQL4 Expert Advisors operate on an event-driven architecture rather than traditional linear execution. Understanding the precise lifecycle of each event function is fundamental to building robust, production-grade trading systems. Poor event handling leads to memory leaks, redundant calculations, and missed trading opportunities.
1. OnInit(): The Single-Execution Gateway
The `OnInit()` function executes exactly once when an EA attaches to a chart or when parameters change. Its return value determines whether the EA runs at all.
```cpp
// Complete OnInit implementation with validation
int OnInit() {
Print("EA initializing on symbol: ", Symbol(), " period: ", Period());
// Validate critical inputs
if(AccountBalance() <= 0) {
Print("ERROR: Invalid account balance");
return INIT_FAILED;
}
double minLot = MarketInfo(Symbol(), MODE_MINLOT);
double maxLot = MarketInfo(Symbol(), MODE_MAXLOT);
if(LotSize < minLot || LotSize > maxLot) {
Print("Lot size out of range. Min: ", minLot, " Max: ", maxLot);
return INIT_PARAMETERS_INCORRECT;
}
// Initialize persistent objects
if(!ObjectCreate(0, "StatusLabel", OBJ_LABEL, 0, 0, 0)) {
Print("Failed to create status label");
return INIT_FAILED;
}
ObjectSetInteger(0, "StatusLabel", OBJPROP_XDISTANCE, 10);
ObjectSetInteger(0, "StatusLabel", OBJPROP_YDISTANCE, 30);
// Start timer for periodic tasks (60 seconds)
if(!EventSetTimer(60)) {
Print("Failed to set timer");
return INIT_FAILED;
}
return INIT_SUCCEEDED;
}
```
2. OnTick(): The Heartbeat of Your EA
`OnTick()` fires on every price update from the broker. In active markets, this can exceed 500 calls per minute. Poorly optimized `OnTick()` logic kills backtest performance and causes execution lag.
```cpp
// Optimized OnTick with state management
datetime lastBarTime = 0;
datetime lastExecutionTime = 0;
int tickCounter = 0;
void OnTick() {
tickCounter++;
// Rate limiting: skip if last execution less than 100ms ago
datetime now = GetTickCount();
if(now - lastExecutionTime < 100) return;
lastExecutionTime = now;
// Detect new bar (critical for avoiding redundant signals)
static datetime s_lastBarTime = 0;
if(Time[0] == s_lastBarTime) return; // Same bar, skip strategy evaluation
s_lastBarTime = Time[0];
// New bar confirmed - execute strategy logic
EvaluateTradingConditions();
// Periodic status update every 1000 ticks
if(tickCounter >= 1000) {
UpdateStatusDisplay();
tickCounter = 0;
}
}
void EvaluateTradingConditions() {
// Only use closed bar data (index 1, not 0)
double maFast = iMA(NULL, 0, FastMAPeriod, 0, MODE_SMA, PRICE_CLOSE, 1);
double maSlow = iMA(NULL, 0, SlowMAPeriod, 0, MODE_SMA, PRICE_CLOSE, 1);
if(maFast > maSlow && !PositionExists(OP_BUY)) {
OpenBuyOrder();
}
}
```
3. OnTimer(): Precision Control Without Tick Dependency
Timer events provide deterministic execution intervals, perfect for daily reports, risk checks, or trailing stop updates.
```cpp
// Timer implementation with multiple interval support
void OnTimer() {
static datetime lastDailyCheck = 0;
datetime currentTime = TimeCurrent();
// Daily report at 00:01 server time
MqlDateTime dt;
TimeToStruct(currentTime, dt);
if(dt.hour == 0 && dt.min == 1 && currentTime != lastDailyCheck) {
GenerateDailyReport();
lastDailyCheck = currentTime;
}
// Hourly risk assessment
if(dt.min == 0) {
CheckDrawdownAndAdjustRisk();
}
// Trailing stop update every 30 seconds
static datetime lastTrailUpdate = 0;
if(currentTime - lastTrailUpdate >= 30) {
UpdateTrailingStops();
lastTrailUpdate = currentTime;
}
}
void UpdateTrailingStops() {
for(int i = OrdersTotal() - 1; i >= 0; i--) {
if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
if(OrderMagicNumber() != MagicNumber) continue;
double newSL = 0;
if(OrderType() == OP_BUY) {
newSL = Bid - TrailingPips * Point;
if(newSL > OrderStopLoss()) {
OrderModify(OrderTicket(), OrderOpenPrice(), newSL, OrderTakeProfit(), 0, clrNONE);
}
}
}
}
```
4. OnDeinit(): Cleanup That Prevents Crashes
Proper resource cleanup prevents memory leaks and orphaned objects that accumulate across EA reloads.
```cpp
void OnDeinit(const int reason) {
// Log the unload reason for debugging
switch(reason) {
case REASON_REMOVE: Print("EA removed manually"); break;
case REASON_RECOMPILE: Print("EA unloaded for recompilation"); break;
case REASON_CHARTCHANGE: Print("Symbol or period changed"); break;
case REASON_PARAMETERS: Print("Input parameters changed"); break;
case REASON_ACCOUNT: Print("Account switched"); break;
default: Print("Unknown deinit reason: ", reason);
}
// Stop timer if active
EventStopTimer();
// Delete all objects created by this EA
ObjectsDeleteAll(0, "StatusLabel"); // Delete specific objects
ObjectsDeleteAll(0, "Signal_"); // Delete by prefix
// Close any open file handles
int fileHandle = FileOpen("log.txt", FILE_READ|FILE_WRITE);
if(fileHandle != INVALID_HANDLE) FileClose(fileHandle);
Print("EA cleanup complete. Total objects remaining: ", ObjectsTotal(0));
}
```
5. Complete Event-Driven EA Template
```cpp
//+------------------------------------------------------------------+
//| Production Event-Driven EA Template |
//+------------------------------------------------------------------+
input double LotSize = 0.1;
input int MagicNumber = 12345;
input int TrailingPips = 20;
datetime lastBarTime;
int ticketCounter;
int OnInit() {
if(LotSize <= 0) return INIT_PARAMETERS_INCORRECT;
EventSetTimer(30); // 30-second timer
lastBarTime = Time[0];
Print("EA initialized on ", Symbol());
return INIT_SUCCEEDED;
}
void OnTick() {
// New bar detection only
if(Time[0] == lastBarTime) return;
lastBarTime = Time[0];
// Bar-closed logic here
ExecuteStrategy();
}
void OnTimer() {
// Periodic tasks: trailing stops, status updates, risk checks
UpdateTrailingStops();
UpdateDashboard();
}
void OnDeinit(const int reason) {
EventStopTimer();
ObjectsDeleteAll(0);
Print("EA terminated. Reason: ", reason);
}
void ExecuteStrategy() {
double maFast = iMA(Symbol(), 0, 10, 0, MODE_SMA, PRICE_CLOSE, 1);
double maSlow = iMA(Symbol(), 0, 30, 0, MODE_SMA, PRICE_CLOSE, 1);
if(maFast > maSlow && !PositionExists()) {
OrderSend(Symbol(), OP_BUY, LotSize, Ask, 3, 0, 0, "EventEA", MagicNumber, 0, clrGreen);
}
}
bool PositionExists() {
for(int i = OrdersTotal() - 1; i >= 0; i--) {
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if(OrderMagicNumber() == MagicNumber)
return true;
}
return false;
}
```
Reference: MQL4 Documentation (docs.mql4.com), “Event Handling Functions”; Young, Andrew. “Expert Advisor Programming” (2019).