Wie sieht so ein EA aus?

Beispiel eines einfachen Expert Advisors (EA)

Dieses Beispiel zeigt auf einfache Weise, wie ein sogenannter Trading-Algo (Expert Advisor) grundsätzlich aufgebaut sein kann.

Der Expert Advisor überprüft alle 5 Sekunden, ob sich noch offene Trades im MetaTrader befinden.
Sobald keine Positionen mehr offen sind, wird das globale AlgoTrading automatisch deaktiviert.

Es handelt sich dabei bewusst um einen sehr einfachen Expert Advisor, der keine eigene Trading-Strategie enthält.
Eine echte Handelslogik mit Ein- und Ausstiegen, Risiko-Management und Marktanalysen umfasst in der Regel deutlich mehr Code und Komplexität.

Auf dem Markt gibt es mittlerweile sehr viele Expert Advisors. Die meisten sind jedoch so konzipiert, dass sie dauerhaft laufen, ohne sich selbst zu beenden. Da man nicht ständig vor dem PC sitzt und jeden Algo überwacht, kann es sinnvoll sein, ein zusätzliches Kontroll-Werkzeug zu verwenden.

Genau hier kommt dieser EA zum Einsatz:
Er ermöglicht es, das AlgoTrading automatisch zu stoppen, ohne offene Trades manuell schließen zu müssen.
Damit eignet er sich ideal als kleines Hilfs-Tool, um nach dem Abschluss aller Positionen wieder die volle Kontrolle zu behalten.

Dieser Code funktioniert zwar, aber er ist extrem teuer was den Resourcen verbrauch angeht.

//+------------------------------------------------------------------+
//|                                              RefactorStopper.mq4 |
//|                                    Copyright 2025, Refactor GmbH |
//|                                          https://www.refactor.li |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Refactor GmbH"
#property link      "https://www.refactor.li"
#property version   "1.00"
#property strict

#import "user32.dll"
int GetAncestor(int hWnd, int gaFlags);
int PostMessageA(int hWnd, int Msg, int wParam, int lParam);
#import

#define WM_COMMAND       0x0111
#define GA_ROOT          2
#define MT_WMCMD_EXPERTS 32851

static bool already_disabled = false;
static datetime LastCheck;

//+------------------------------------------------------------------+
bool HasAnyOpenPositions()
{
   return (OrdersTotal() > 0);
}

//+------------------------------------------------------------------+
void DisableGlobalAlgoTrading()
{
   if(already_disabled) return;

   if(!IsTradeAllowed())
   {
      Print("AlgoTrading bereits deaktiviert.");
      already_disabled = true;
      return;
   }

   int chart_hwnd   = WindowHandle(Symbol(), Period());
   int terminal_hwnd = GetAncestor(chart_hwnd, GA_ROOT);

   PostMessageA(
      terminal_hwnd,
      WM_COMMAND,
      MT_WMCMD_EXPERTS,
      0
   );

   Print("Keine offenen Positionen mehr → Global AlgoTrading deaktiviert!");
   already_disabled = true;
}

//+------------------------------------------------------------------+
void OnTick()
{
   datetime current = TimeCurrent();
   if(LastCheck + 5 > current)
   {
      return;
   }

   LastCheck = TimeCurrent();
   if(!HasAnyOpenPositions())
      DisableGlobalAlgoTrading();

Eine bessere Variante, die Resourcen schonender ist, aber nahezu das gleiche macht, ist das hier:

Charts werden nach Symbol geschlossen, wenn deren Trades geschlossen sind. Das ist bei weitem nicht so Resourcenintensiv.

//+------------------------------------------------------------------+
//| RefactorCurrencyStopper.mq4                                      |
//| © 2026 Refactor GmbH                                             |
//| https://www.refactor.li                                          |
//+------------------------------------------------------------------+
#property copyright "Refactor GmbH, 2026"
#property link "https://www.refactor.li"
#property version "1.10"
#property strict


// ---------------- USER SETTINGS -----------------------------------
input int CheckIntervalSeconds = 5; // Check interval in seconds
input string SymbolToStop = "EURUSD";
// ------------------------------------------------------------------


static bool Done = false;
string InstanceKey;


//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit()
{
   // Symbol-specific instance lock (allows multi-symbol usage)
   InstanceKey = "Refactor_Stopper_Running_" + SymbolToStop;
   
   
   if(GlobalVariableCheck(InstanceKey))
   {
      Print("Stopper already running for ", SymbolToStop);
      return INIT_FAILED;
   }
   
   
   GlobalVariableSet(InstanceKey, TimeCurrent());
   
   
   EventSetTimer(CheckIntervalSeconds);
   Print("Refactor Currency Stopper started for ", SymbolToStop);
   
   
   return INIT_SUCCEEDED;
}


//+------------------------------------------------------------------+
//| Expert deinitialization                                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   EventKillTimer();
   GlobalVariableDel(InstanceKey);
}


//+------------------------------------------------------------------+
//| Timer event (NO OnTick usage)                                    |
//+------------------------------------------------------------------+
void OnTimer()
{
   if(Done)
      return;
   
   
   // As long as trades for this symbol are still open → do nothing
   if(HasOpenTradesForSymbol(SymbolToStop))
      return;
   
   
   // No trades left → close all charts for this symbol
   CloseAllChartsForSymbol(SymbolToStop);
   Done = true;
}


//+------------------------------------------------------------------+
//| Check if any open trades exist for a specific symbol             |
//+------------------------------------------------------------------+
bool HasOpenTradesForSymbol(string sym)
{
   int total = OrdersTotal();
      
   for(int i = 0; i < total; i++)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == sym)
         return true;
      }
   }
   return false;
}


//+------------------------------------------------------------------+
//| Close all charts for a symbol (except this EA's chart)           |
//+------------------------------------------------------------------+
void CloseAllChartsForSymbol(string sym)
{
   long current_chart = ChartID();
   long chart_id = ChartFirst();  
   
   while(chart_id >= 0)
   {
      long next_chart = ChartNext(chart_id);
      
      
      if(ChartSymbol(chart_id) == sym)
      {
         // Do NOT close the chart this EA is running on
         if(chart_id != current_chart)
         {
            Print("Closing chart ", chart_id, " for ", sym);
            ChartClose(chart_id);
         }
      }

      chart_id = next_chart;
   }

   Print("✔ All charts for ", sym, " have been closed");
      
   // Optional: remove this EA as well (uncomment if desired)
   // ExpertRemove();
}