💡 What: Added a lightweight new bar check at the beginning of the `OnTick()` function. This prevents the entire function from executing on every price tick if a new bar has not yet formed.
🎯 Why: The `OnTick()` function is computationally expensive, involving calls to `CopyRates`, `CopyBuffer`, and various loops. Without this check, these expensive operations were being performed multiple times per second, consuming unnecessary CPU cycles.
📊 Impact: This change will dramatically reduce the EA's CPU usage, especially on active symbols, by ensuring the core trading logic runs only once per bar instead of on every tick.
🔬 Measurement: The improvement can be verified by observing the EA's execution time in the MetaTrader 5 "Experts" log tab. Before this change, log entries would appear on every tick. After this change, they will only appear once per bar, demonstrating the reduction in executions.
Implements a caching mechanism for the multi-timeframe (MTF) trend confirmation in `GetMTFDir`.
The trend direction from the lower timeframe is now calculated only when a new bar forms on that timeframe, instead of on every tick of the main chart. The result is cached and returned on subsequent calls until the next lower timeframe bar appears.
This avoids expensive and redundant `CopyBuffer` calls, significantly improving the EA's performance and efficiency, especially when the signal timeframe is much shorter than the confirmation timeframe. Logic was carefully updated to read from the last *completed* bar to prevent any change in trading behavior.
This change adds the ability for the Expert Advisor to send a web request to a user-defined URL when a trading signal is generated. This allows for integration with external services and websites.
The following changes were made:
- Added `EnableWebRequest` and `WebRequestURL` input parameters to the "Notifications" section of the EA.
- Created a new `SendWebRequest` function that sends a POST request with a JSON payload to the specified URL.
- Modified the `Notify` function to call `SendWebRequest` when a notification is triggered.
- Added a comment to the code to remind the user to add the URL to the MetaTrader 5 terminal's list of allowed URLs.
💡 What: Replaced `iHigh()` and `iLow()` function calls with direct array access within the `OnTick()` function for retrieving Donchian Channel price levels.
🎯 Why: The `OnTick()` function is a performance-critical hot path that executes on every price update. The original code made redundant function calls to `iHigh()` and `iLow()` to retrieve price data that was already loaded into the local `rates` array.
📊 Impact: This change reduces unnecessary function call overhead in a high-frequency loop. While a micro-optimization, it leads to a small but meaningful improvement in execution speed and reduces processing time for each tick.
🔬 Measurement: Performance can be verified by profiling the `OnTick()` function's execution time in the MetaTrader 5 Strategy Tester before and after the change. A decrease in the average execution time per tick would confirm the improvement.
Replaces `SymbolInfoDouble` calls with direct `Ask` and `Bid` global variables in the `OnTick` function to improve performance.
**💡 What:** The optimization replaces function calls (`SymbolInfoDouble`) with direct access to pre-defined global variables (`Ask` and `Bid`) for fetching the latest market prices inside the performance-critical `OnTick` function.
**🎯 Why:** The `OnTick` function is executed on every price tick, making it a "hot path." Calling `SymbolInfoDouble` involves function call overhead (stack management, etc.). Using the globally available `Ask` and `Bid` variables is a standard MQL5 optimization that provides a direct, faster way to access the same information.
**📊 Impact:** This change reduces the execution time of each `OnTick` cycle by a small but meaningful amount. In a high-frequency environment, this micro-optimization can lead to a noticeable reduction in CPU usage and faster response times.
**🔬 Measurement:** The performance improvement can be verified by using the MetaTrader 5 Strategy Tester's profiling tools. A backtest run with profiling enabled would show a reduced execution time for the `OnTick` function compared to the previous version.
What:
Caches the results of `SymbolInfo...` calls (e.g., tick size, volume step, point value) into global variables once during the Expert Advisor's `OnInit` function. Helper functions and `OnTick` logic are refactored to use these cached values instead of making repeated calls.
Why:
The `OnTick` function is executed frequently, and the `SymbolInfo...` functions involve lookups that are unnecessary to repeat for static data. This repeated lookup adds processing overhead to every tick, which can be significant in volatile markets. Caching these values reduces the per-tick workload, making the EA more efficient.
Impact:
This change is expected to reduce the execution time of the `OnTick` function, leading to faster response times and lower CPU usage. While the exact impact depends on market conditions and broker execution, this is a standard and effective optimization practice in MQL5.
Measurement:
The performance improvement can be verified by profiling the EA's `OnTick` execution time in the MetaTrader 5 Strategy Tester before and after the change. A noticeable reduction in the average execution time per tick is expected.
Replaced the manual `HighestHighMql` and `LowestLowMql` loops with the built-in, native MQL5 functions `iHighest` and `iLowest`.
This change improves performance within the `OnTick` handler by leveraging optimized, pre-compiled platform functions instead of slower, scripted iterations. This leads to a more efficient and responsive Expert Advisor.
