Handelsdisziplin in Code verankern (Teil 1): Mit MQL5 strukturelle Disziplin im Live-Trading schaffen
26
0
Inhalt
- Einführung
- Warum Regeln versagen
- Warum Psychologie allein nicht ausreicht
- Disziplin als Systemergebnis
- Von Regeln zu Beschränkungen
- Umfang und Zielgruppe
- Schlussfolgerung
Einführung
Um beim Trading Geld zu verdienen, kommt es nicht allein auf die Qualität der Strategie an. Eine Strategie kann logisch fundiert, im Backtest erprobt und statistisch valide sein und dennoch unter Live-Marktbedingungen scheitern, wenn die Disziplin unter Druck nachlässt. Märkte sind dynamisch, volatil und emotional anspruchsvoll – doch die Disziplin muss stets gewahrt bleiben.
Wenn eines der folgenden Muster auftritt, ist dieser Artikel für Sie relevant:
- Es gibt zwar klare Regeln, doch unter dem Druck der aktuellen Marktlage werden diese oft gelockert oder umgangen.
- Die Gewinnziele werden erreicht, doch der Handel geht weiter und zehrt die Gewinne auf.
- Es werden tägliche Handels- oder Risikolimits festgelegt, die jedoch während der Handelssitzung außer Kraft gesetzt werden.
- Es wird versucht, Verluste auszugleichen, anstatt sich an vordefinierte Stopps zu halten.
- Regeln existieren zwar auf dem Papier, setzen sich jedoch in Echtzeit nicht von selbst durch.
Insgesamt führen diese Verhaltensweisen unweigerlich zu Verlusten – Regeln, die man im entscheidenden Moment bricht, können einem manchmal zum Verhängnis werden. Das sind keine strategischen Fehler – es sind Durchsetzungsfehler.
Dieser Artikel geht das Problem strukturell an. Mithilfe von MQL5 entwickeln wir Steuerungsebenen (Governance-Ebenen), die parallel zu Ihrer Handelslogik arbeiten, die Ausführung in Echtzeit überwachen und Aktionen blockieren, sobald Grenzwerte überschritten werden. Das Ziel besteht nicht darin, Ihre Strategie neu zu gestalten, sondern die Lücke bei der Durchsetzung zu schließen – damit Disziplin nicht mehr im Ermessensspielraum des Traders liegt, sondern automatisch gewährleistet ist.
Warum Regeln versagen
Nach jahrelanger Beobachtung strukturierter Devisenhandelssysteme im Live-Handel zeichnet sich ein Muster ab: Die Trader verstehen zwar die Regeln, doch unter dem Druck des Live-Marktes verlagert sich die Ausführung oft von disziplinierter Planung hin zu reaktiven Entscheidungen. Was als klar definierte Strategie beginnt, verwandelt sich nach und nach in eine Abfolge von Maßnahmen, die eher von unmittelbaren Kursbewegungen, Zuversicht oder Dringlichkeit bestimmt werden als von einer bewussten Struktur.
Die folgende Grafik veranschaulicht ein bekanntes Szenario. Eine valide Supply-Zone wird identifiziert, das Risiko wird festgelegt, und der erste Trade erfolgt nach Plan. Solange der Kurs innerhalb dieser Zone bleibt, werden weitere Trades getätigt. Jede einzelne Position mag für sich genommen gerechtfertigt erscheinen, doch in ihrer Gesamtheit erhöhen sie das Risiko und schmälern die Gewinne. Die Rahmenbedingungen haben sich nicht geändert – das Verhalten schon. Dies zeigt, dass selbst disziplinierte Strategien unter dem Druck des Live-Marktes scheitern können.
Das Problem liegt selten an einer mangelhaften Vorbereitung. Die meisten Trader verfügen über strukturierte Strategien, klar definierte Ein- und Ausstiegsregeln, tägliche Handelslimits, Obergrenzen für das Risiko pro Trade, Gewinnziele und Drawdown-Grenzen. Der Plan ist schlüssig, messbar und theoretisch umsetzbar. Sobald man jedoch den realen Marktbedingungen ausgesetzt ist, gerät die Ausführung ins Wanken: Die Handelsfrequenz steigt, die Gewinnziele werden im Laufe der Sitzung nach oben angepasst, Verlustlimits werden ignoriert und die Positionsgröße wird flexibel gehandhabt. Die Strategie bleibt zwar bestehen, doch ihr Einfluss auf die Entscheidungsfindung nimmt allmählich ab.
Diese schleichende Verhaltensänderung ist nichts Neues. Jesse Livermore, einer der legendärsten Spekulanten der Geschichte, führte seine schwersten Rückschläge immer wieder nicht auf fehlerhafte Marktanalysen zurück, sondern auf mangelnde Disziplin – darauf, dass er sich nicht an seine eigenen Regeln hielt, wenn Emotionen, Hoffnungen oder äußere Einflüsse die Oberhand gewannen.
Die eigentliche Ursache ist eine Lücke bei der Durchsetzung. Schriftliche Regeln beschreiben die Absicht, sind jedoch nicht aktiv an der Entscheidungsfindung beteiligt. Trader legen zwar Limits fest, überschreiten diese aber dennoch; sie setzen sich zwar Gewinnziele, handeln aber weiter; oder sie planen, nach Verlusten aufzuhören, versuchen stattdessen aber, diese wieder auszugleichen. Ohne Echtzeitüberwachung, Zählung und Kontrollmechanismen hängt die Disziplin vollständig vom momentanen Urteilsvermögen ab – genau dann, wenn dieses am anfälligsten ist.
Ein Trader beginnt die Handelssitzung mit einem einfachen und disziplinierten Ziel: 20 Dollar zu verdienen und dann den Handel zu beenden. Das Ziel ist bescheiden, klar messbar und steht im Einklang mit soliden Grundsätzen des Risikomanagements. Zu Beginn der Handelssitzung spielt der Markt mit, und schon nach ein oder zwei Trades ist das Ziel erreicht. In diesem Moment ist der Plan technisch gesehen gelungen, doch der Handel geht weiter. Der Wandel vollzieht sich schrittweise, fast unmerklich. Die Marktentwicklung scheint günstig zu sein, das Vertrauen wächst, und das ursprüngliche Ziel erscheint allmählich als unnötig konservativ.
Was als kontrolliertes und genau festgelegtes Ziel begann, weitet sich still und leise aus – zunächst auf 50 Dollar, dann auf 100 Dollar und schließlich auf Beträge, die ursprünglich gar nicht Teil des Plans waren. Mit steigenden Erwartungen nimmt die Handelsfrequenz zu, die Positionsgröße wächst und die Risikotoleranz passt sich unmerklich nach oben an. Die Marktaktivität bleibt hoch, doch die Ausführung ist nicht mehr an den ursprünglichen Regeln verankert. Wenn es schließlich zu einem Verlust kommt, besteht die Reaktion nicht darin, aufzuhören, sondern den Verlust wieder hereinzuholen. Am Ende der Sitzung ist der anfängliche Gewinn von 20 Dollar verschwunden, und möglicherweise sind weitere Verluste hinzugekommen. Die Regeln wurden nicht vergessen; sie wurden in diesem Moment bewusst beiseitegeschoben.
Geplante Disziplin vs. Realität der Ausführung im Live-Handel
| Aspekt | Geplante Disziplin | Live-Ausführung unter Druck |
|---|---|---|
| Tagesziel | Stop nach +20 $ | Das Ziel wird im Verlauf der Sitzung erweitert |
| Häufigkeit des Handels | Begrenzt und selektiv | Verstärkt und impulsiv |
| Risikoexposition | Festgelegt und vordefiniert | Schrittweise erhöht |
| Entscheidungsgrundlage | Plan für die Zeit vor der Sitzung | Emotionen und Dynamik in Echtzeit |
| Reaktion nach Gewinn | Handel beenden | Weiter handeln |
| Ergebnis: | Kleiner, kontrollierter Gewinn | Gewinne aufgezehrt oder wieder abgegeben |
Sowohl das Beispiel im Diagramm als auch das Szenario zum täglichen Gewinn offenbaren dieselbe strukturelle Schwäche. Die Regeln beschreiben die Absicht, sind jedoch nicht an der Ausführung beteiligt. Es gibt keinen Mechanismus, um Transaktionen zu zählen, kumulative Ergebnisse zu verfolgen oder zu erkennen, dass vordefinierte Ziele bereits erreicht wurden.
Ohne strukturelle Durchsetzung wird Disziplin in dem Moment zur Option, in dem der Druck, das Selbstvertrauen oder die Chancen zunehmen. Regeln, die während der Planung ausreichend erscheinen, versagen unter realen Bedingungen oft, da sie auf Gedächtnis und Urteilsvermögen beruhen – und genau diese sind in Stresssituationen am anfälligsten.
Warum Psychologie allein nicht ausreicht
Da Verstöße gegen die Disziplin oft mit Emotionen verbunden sind, wird in der Trading-Ausbildung in der Regel ein besonderer Schwerpunkt auf die Psychologie gelegt. Trader werden dazu ermutigt, ihre Denkweise zu verbessern, ihre emotionale Belastbarkeit zu stärken und mehr Selbstbeherrschung zu entwickeln. Diese Bemühungen sind wertvoll, und psychologisches Bewusstsein spielt eine wichtige Rolle für die Leistungsfähigkeit. Die Erfahrung zeigt jedoch immer wieder, dass eine psychologische Vorbereitung allein nicht ausreicht.
Angst, Selbstvertrauen, Dringlichkeit und Frustration sind keine Charakterfehler. Das sind natürliche Reaktionen auf Unsicherheit und finanzielle Risiken. Es ist unrealistisch zu erwarten, dass diese Reaktionen im Live-Handel verschwinden, unabhängig vom Erfahrungsstand. Selbst Trader mit fundierten Marktkenntnissen können sich anders verhalten, wenn echtes Kapital den Schwankungen in Echtzeit ausgesetzt ist.
Das Problem hat auch eine zeitliche Dimension. Die meisten Regelverstöße entstehen nicht nach längerer innerer Reflexion. Sie treten schnell auf, manchmal innerhalb von Sekunden, noch bevor das bewusste Denken Zeit hat, einzugreifen. Bis das Bewusstsein eingreift, ist die Entscheidung bereits umgesetzt worden. Die Psychologie kann zwar helfen zu erklären, warum ein Fehler passiert ist, verhindert jedoch selten die Handlung genau in dem Moment, in dem der Druck seinen Höhepunkt erreicht.
Ohne einen externen Mechanismus, der in der Lage ist, ein Verhalten zu verlangsamen, zu blockieren oder umzulenken, verfügt die mentale Disziplin über keine strukturelle Verstärkung. Sie kann Zurückhaltung fördern, aber nicht durchsetzen.
Disziplin als Systemergebnis
Irgendwann wird klar, dass Disziplin nicht ausschließlich auf interner Kontrolle beruhen kann. Wenn sich das Verhalten unter Druck durchweg ändert, muss ein Teil der Verantwortung bei dem Umfeld liegen, in dem Entscheidungen getroffen werden. Disziplin muss nicht als persönlicher Kampf betrachtet werden. Sie kann als Ergebnis des Systems verstanden werden.
Wenn Grenzen direkt in das Handelsumfeld integriert sind, ändert sich das Verhalten automatisch. Grenzen werden nicht mehr im Gedächtnis behalten – sie werden überwacht. Verstöße werden nicht mehr diskutiert – sie werden sofort erkannt. Die Ausführung bleibt nicht deshalb innerhalb vordefinierter Grenzen, weil persönliche Zurückhaltung herrscht, sondern weil die Struktur keine Abweichungen zulässt.
Dadurch verlagert sich der Schwerpunkt der Disziplin weg von der Entscheidung von Moment zu Moment hin zur Konzeption. Der Druck ist zwar nach wie vor vorhanden, bestimmt aber nicht mehr das Verhalten. Die Struktur begrenzt ihn. So betrachtet ist Disziplin nicht mehr etwas, wofür der Trader ständig kämpfen muss, um sie aufrechtzuerhalten. Sie wird zu etwas, das das Handelsumfeld durch seine Beschränkungen ganz natürlich hervorbringt.
Von Regeln zu Beschränkungen
An dieser Stelle wird die Unterscheidung zwischen dem Kennen einer Regel und ihrer aktiven Durchsetzung entscheidend. Schriftliche Richtlinien beschreiben die Absicht – sie legen dar, was geschehen soll –, sind jedoch nicht an der tatsächlichen Ausführung von Handelsgeschäften beteiligt. Unter dem Druck der realen Marktbedingungen ist es genau diese Kluft zwischen Absicht und Umsetzung, an der die Disziplin am häufigsten ins Wanken gerät.
Eine Regel, die das Verhalten nicht überwachen und bei Verstößen nicht eingreifen kann, ist kein Kontrollmechanismus.
Eine Regel wird erst dann zu einem wirksamen Instrument zur Disziplinsicherung, wenn sie in das Handelssystem eingebettet ist, die Aktivitäten kontinuierlich überwacht und sofortige Maßnahmen ergreifen kann.
Praktisches Beispiel: Disziplin in den Code integrieren
Um zu veranschaulichen, wie diese Umsetzung von einer Regel in eine Beschränkung in der Praxis funktioniert, betrachten Sie die folgenden Beispiele. In den meisten Fällen waren die Regeln im Voraus klar festgelegt worden. Diese Ausschnitte sind bewusst sehr knapp gehalten. Sie legen keine Handelsstrategien fest und verwalten keine Positionen. Sie sollen veranschaulichen, wie disziplinbezogene Regeln programmgesteuert eingebettet werden können, damit sie in Echtzeit aktiv bleiben. In der Praxis müssen Ereignisfunktionen (z. B. OnInit, OnTimer) in einer Produktions-EA entsprechend zusammengeführt werden.
Beispiel 1: Begrenzung der Handelshäufigkeit (Overtrading)
Ermessensregel: Begrenzen Sie die Anzahl der Trades, die Sie an einem Tag tätigen. Trader vergessen oder ignorieren diese Grenze oft nach frühen Gewinnen oder während längerer Marktaktivitäten, was zu übermäßigem Handel und erhöhtem Risiko führt.
Der folgende Codeausschnitt veranschaulicht die Durchsetzung der Handelshäufigkeit. Der Codeausschnitt zählt die Trades pro Tag und blockiert jeden Versuch, das Limit zu überschreiten.
Als technische Beschränkung mit echter Blockierung umgesetzt
#property strict input int MaxTradesPerDay = 5; int tradesToday = 0; datetime dayStartTime = 0; bool tradeBlocked = false; //------------------------------------------------------------------- // Reset daily counters //------------------------------------------------------------------- void ResetDailyCounters() { tradesToday = 0; dayStartTime = iTime(_Symbol, PERIOD_D1, 0); tradeBlocked = false; } //------------------------------------------------------------------- // Initialization //------------------------------------------------------------------- int OnInit() { ResetDailyCounters(); return(INIT_SUCCEEDED); } //------------------------------------------------------------------- // Track new trade transactions and enforce //------------------------------------------------------------------- void OnTradeTransaction(const MqlTradeTransaction &trans, const MqlTradeRequest &request, const MqlTradeResult &result) { if(trans.type != TRADE_TRANSACTION_DEAL_ADD) return; // Reset if new trading day datetime today = iTime(_Symbol, PERIOD_D1, 0); if(today != dayStartTime) ResetDailyCounters(); // Select deal if(HistoryDealSelect(trans.deal)) { long entryType = HistoryDealGetInteger(trans.deal, DEAL_ENTRY); if(entryType == DEAL_ENTRY_IN) tradesToday++; } if(tradesToday >= MaxTradesPerDay) { tradeBlocked = true; Alert("Daily trade limit reached — further trades blocked"); } } //------------------------------------------------------------------- // Centralized trade gateway with enforcement //------------------------------------------------------------------- bool TryOpenOrder(MqlTradeRequest &req, MqlTradeResult &res) { if(tradeBlocked) { Print("Trade blocked: Daily limit exceeded"); return false; // Actual blocking: trade not sent } if(!OrderSend(req, res)) { Print("OrderSend failed: ", res.comment); return false; } return true; // Trade executed if allowed }
Die Handelsaktivitäten werden anhand von Transaktionsereignissen objektiv erfasst. Wenn die Anzahl der Trades das Limit erreicht, werden weitere Orders blockiert, indem in der Funktion TryOpenOrder() der Wert „false“ zurückgegeben wird, wodurch verhindert wird, dass neue Trades gesendet werden. Um dies in einen bestehenden EA zu integrieren, ersetzen Sie alle Aufrufe von OrderSend() durch TryOpenOrder(). Umgeben Sie beispielsweise im OnTick()-Funktionsblock oder im Signal-Handler Ihres EA die Handelsanforderung wie folgt: if(TryOpenOrder(request, result)) { /* erfolgreich */ } else { /* blockiert */ }. Dadurch wird die Durchsetzung gewährleistet, ohne die Logik der Kernstrategie zu verändern.
Beispiel 2: Gewinne sichern (Übertrading nach Gewinnen)
Ermessensregel: Beenden Sie den Handel, sobald Sie Ihr Tagesgewinnziel erreicht haben, um Gewinne zu sichern und ein übermäßiges Risiko zu vermeiden.
Als technische Beschränkung mit echter Blockierung umgesetzt
// ---------- User Input ---------- input double DailyProfitTarget = 2.0; // Target profit in percent // ---------- Internal State ---------- double dayStartEquity = 0.0; datetime dayStartTime = 0; bool profitLimitReached = false; // ---------- Initialization ---------- int OnInit() { ResetProfitTracking(); EventSetTimer(1); // Check every second return(INIT_SUCCEEDED); } // ---------- Reset Logic ---------- void ResetProfitTracking() { dayStartTime = iTime(_Symbol, PERIOD_D1, 0); dayStartEquity = AccountInfoDouble(ACCOUNT_EQUITY); profitLimitReached = false; } // ---------- Monitoring Logic ---------- void CheckDailyProfitLimit() { datetime today = iTime(_Symbol, PERIOD_D1, 0); // Reset if new trading day if(today != dayStartTime) ResetProfitTracking(); if(profitLimitReached) return; double currentEquity = AccountInfoDouble(ACCOUNT_EQUITY); double gainPercent = ((currentEquity - dayStartEquity) / dayStartEquity) * 100.0; if(gainPercent >= DailyProfitTarget) { profitLimitReached = true; Alert("Daily profit target reached — further trading restricted"); } } // ---------- Timer Event ---------- void OnTimer() { CheckDailyProfitLimit(); } //------------------------------------------------------------------- // Centralized trade gateway with enforcement (integrate with Example 1's TryOpenOrder) //------------------------------------------------------------------- bool TryOpenOrder(MqlTradeRequest &req, MqlTradeResult &res) { if(profitLimitReached) { Print("Trade blocked: Profit target reached"); return false; // Actual blocking } // ... (add OrderSend logic here or merge with full gateway) return true; } //+------------------------------------------------------------------+
Das System überwacht fortlaufend den Equity-Zuwachs im Verhältnis zum Tagesbeginn. Sobald das Gewinnziel erreicht ist, wird das Flag gesetzt, und TryOpenOrder() blockiert neue Trades. Integration: Fügen Sie die Überprüfung „profitLimitReached“ in Ihre zentrale Funktion „TryOpenOrder()“ ein, um eine einheitliche Durchsetzung zu gewährleisten.
Beispiel 3: Eindämmung von Verlusteskalationen (Drawdown-Kontrolle)
Ermessensregel: Beenden Sie den Handel, sobald ein vorab festgelegtes Verlustlimit für den Tag überschritten wird, um zu verhindern, dass emotionale Reaktionen die Verluste noch vergrößern.
Als technische Beschränkung mit echter Blockierung umgesetzt
// ---------- User Input ---------- input double MaxDailyLoss = 3.0; // Max daily loss in percent // ---------- Internal State ---------- double dayStartBalance = 0.0; datetime dayStartTimeLoss = 0; bool lossLimitBreached = false; // ---------- Initialization ---------- int OnInit() { ResetLossTracking(); EventSetTimer(1); // Check every second return(INIT_SUCCEEDED); } // ---------- Reset Logic ---------- void ResetLossTracking() { dayStartTimeLoss = iTime(_Symbol, PERIOD_D1, 0); dayStartBalance = AccountInfoDouble(ACCOUNT_BALANCE); lossLimitBreached = false; } // ---------- Monitoring Logic ---------- void CheckDailyLossLimit() { datetime today = iTime(_Symbol, PERIOD_D1, 0); // Reset if new trading day if(today != dayStartTimeLoss) ResetLossTracking(); if(lossLimitBreached) return; double currentEquity = AccountInfoDouble(ACCOUNT_EQUITY); double lossPercent = ((dayStartBalance - currentEquity) / dayStartBalance) * 100.0; if(lossPercent >= MaxDailyLoss) { lossLimitBreached = true; Alert("Daily loss limit breached — trading halted by constraint"); } } // ---------- Timer Event ---------- void OnTimer() { CheckDailyLossLimit(); } //------------------------------------------------------------------- // Centralized trade gateway with enforcement (integrate with Example 1's TryOpenOrder) //------------------------------------------------------------------- bool TryOpenOrder(MqlTradeRequest &req, MqlTradeResult &res) { if(lossLimitBreached) { Print("Trade blocked: Loss limit breached"); return false; // Actual blocking } // ... (add OrderSend logic here or merge with full gateway) return true; }
Verlustgrenzen werden in Echtzeit überwacht. Wird diese Grenze überschritten, erkennt das System dies sofort und stoppt den Handel – unabhängig vom emotionalen Zustand oder dem momentanen Selbstvertrauen des Traders.
Anwendungsbeispiele
Diese Ausschnitte sind nicht als vollständige Handelssysteme gedacht. Stattdessen dienen sie als anschauliche Bausteine, die zentrale Grundsätze verdeutlichen:
- Regeln werden in messbare Bedingungen umgesetzt: Anstatt sich auf das Gedächtnis oder manuelle Überprüfungen zu verlassen, werden die Beschränkungen explizit kodiert.
- Das Verhalten wird kontinuierlich bewertet: Die Überwachung erfolgt fortlaufend und nicht rückwirkend.
- Die Intervention erfolgt zum Zeitpunkt des Verstoßes: Bei Überschreitung von Grenzwerten werden sofort Maßnahmen ausgelöst, wodurch eine Eskalation verhindert wird.
Dieser Wandel von einer absichtsbasierten Disziplin hin zu einer strukturell durchgesetzten Disziplin bildet die Grundlage für die in dieser Reihe entwickelten Steuerungsebenen.
Mit Kontrolle
Ohne Kontrolle
Durchsetzungsinstanz & modularer Constraint-Manager
Während die oben genannten Verfahrensbeispiele veranschaulichen, wie Disziplinarregeln überwacht werden können, erfordert der praktische Live-Handel ein skalierbares, durchsetzbares System. Um dies zu erreichen, führen wir eine zentrale Durchsetzungsinstanz in Kombination mit einem modularen Constraint-Manager ein, das sicherstellt, dass jeder Handel vor der Ausführung anhand aller aktiven Disziplinregeln geprüft wird.
Das obige Diagramm veranschaulicht die gesamte Durchsetzungskette von der Signalerzeugung bis zur Handelsausführung. Alle Handelsanfragen durchlaufen zunächst eine zentrale Durchsetzungsinstanz, bevor sie vom modularen Constraint-Manager ausgewertet werden. Jede Beschränkung arbeitet unabhängig und meldet sich bei einem einheitlichen Entscheidungsknoten, wodurch sichergestellt wird, dass jeder Verstoß die Ausführung sofort blockiert. Ausgeführte Transaktionen werden über Echtzeit-Aktualisierungen der Beschränkungen wieder in das System eingespeist, wodurch eine kontinuierliche Durchsetzung der Regeln ermöglicht wird.
bool TryOpenOrder(MqlTradeRequest &request, MqlTradeResult &result, ConstraintManager &manager) { if(manager.AnyBreached()) { Alert("Trade blocked: ", manager.BreachReason()); return false; // Trade rejected } if(!OrderSend(request,result)) { Print("OrderSend failed: ", result.comment); return false; } return true; // Trade executed successfully }
class IConstraint { public: virtual void ResetIfNewDay() = 0; virtual void UpdateOnTransaction(const MqlTradeTransaction &trans) = 0; virtual bool IsBreached() = 0; virtual string Reason() = 0; };
Diese Schnittstelle folgt einem Entwurfsmuster im Sinne eines Designvertrags und wird über abstrakte Basisklassen implementiert.
- ResetIfNewDay() – Setzt die Zähler zu Beginn eines neuen Handelstages zurück.
- UpdateOnTransaction() – Aktualisiert den internen Status bei jeder Transaktion.
- IsBreached() – Gibt „true“ zurück, wenn die Beschränkung verletzt wurde.
- Reason() – Gibt eine für Menschen lesbare Meldung zurück, die den Verstoß beschreibt.
class ConstraintManager { private: IConstraint* constraints[]; public: void AddConstraint(IConstraint* c) { ArrayAdd(constraints, c); } void ResetAll() { for(int i=0;i<ArraySize(constraints);i++) constraints[i].ResetIfNewDay(); } void UpdateAll(const MqlTradeTransaction &trans) { for(int i=0;i<ArraySize(constraints);i++) constraints[i].UpdateOnTransaction(trans); } bool AnyBreached() { for(int i=0;i<ArraySize(constraints);i++) if(constraints[i].IsBreached()) return true; return false; } string BreachReason() { for(int i=0;i<ArraySize(constraints);i++) if(constraints[i].IsBreached()) return constraints[i].Reason(); return ""; } };
In Produktionssystemen sollten diese Objekte ordnungsgemäß freigegeben oder mithilfe statischer Zuweisung bzw. intelligenter Lebenszyklusverwaltung verwaltet werden. Zeitbezogene Beschränkungen können auch mithilfe eines Timer-Ereignisses zurückgesetzt werden, wenn während einer Sitzung keine Handelsgeschäfte stattfinden.
- AddConstraint() – Fügt eine neue Disziplinregel hinzu.
- ResetAll() – Setzt alle Beschränkungen für einen neuen Handelstag zurück.
- UpdateAll() – Aktualisiert alle Beschränkungen nach einem Handel.
- AnyBreached() / BreachReason() – prüft, ob Regeln verletzt wurden, und gibt den Grund dafür an.
class TradeFrequencyConstraint : public IConstraint { private: int tradesToday; datetime dayStart; int MaxTrades; public: TradeFrequencyConstraint(int maxTrades) { MaxTrades = maxTrades; ResetIfNewDay(); } void ResetIfNewDay() { tradesToday=0; dayStart=iTime(_Symbol,PERIOD_D1,0); } void UpdateOnTransaction(const MqlTradeTransaction &trans) { if(trans.type != TRADE_TRANSACTION_DEAL_ADD) return; if(iTime(_Symbol,PERIOD_D1,0)!=dayStart) ResetIfNewDay(); if(HistoryDealSelect(trans.deal)) if(HistoryDealGetInteger(trans.deal,DEAL_ENTRY)==DEAL_ENTRY_IN) tradesToday++; } bool IsBreached() { return tradesToday>MaxTrades; } string Reason() { return "Daily trade limit exceeded"; } };
2. Gewinnsicherung
class DailyProfitConstraint : public IConstraint { private: double startEquity; datetime dayStart; bool breached; double targetPercent; public: DailyProfitConstraint(double target) { targetPercent=target; ResetIfNewDay(); } void ResetIfNewDay() { startEquity=AccountInfoDouble(ACCOUNT_EQUITY); dayStart=iTime(_Symbol,PERIOD_D1,0); breached=false; } void UpdateOnTransaction(const MqlTradeTransaction &trans) { if(iTime(_Symbol,PERIOD_D1,0)!=dayStart) ResetIfNewDay(); } bool IsBreached() { if(breached) return true; double gain=((AccountInfoDouble(ACCOUNT_EQUITY)-startEquity)/startEquity)*100.0; if(gain>=targetPercent) breached=true; return breached; } string Reason() { return "Daily profit target reached"; } };
3. Eindämmung der Verlusteskalation
class DailyLossConstraint : public IConstraint { private: double startBalance; datetime dayStart; bool breached; double maxLossPercent; public: DailyLossConstraint(double maxLoss) { maxLossPercent=maxLoss; ResetIfNewDay(); } void ResetIfNewDay() { startBalance=AccountInfoDouble(ACCOUNT_BALANCE); dayStart=iTime(_Symbol,PERIOD_D1,0); breached=false; } void UpdateOnTransaction(const MqlTradeTransaction &trans) { if(iTime(_Symbol,PERIOD_D1,0)!=dayStart) ResetIfNewDay(); } bool IsBreached() { if(breached) return true; double loss=((startBalance-AccountInfoDouble(ACCOUNT_EQUITY))/startBalance)*100.0; if(loss>=maxLossPercent) breached=true; return breached; } string Reason() { return "Daily loss limit breached"; } };
Integration in den EA
Sobald die Beschränkungen definiert sind, ist ihre Integration in eine Live-EA unkompliziert. Bei der Initialisierung wird jede Beschränkung beim ConstraintManager registriert. Sobald dann Handelsgeschäfte stattfinden, aktualisiert OnTradeTransaction() alle Beschränkungen in Echtzeit, und jeder Auftrag durchläuft TryOpenOrder(). Das System sorgt nun automatisch für Disziplin: Verstöße werden sofort erkannt, wodurch übermäßiges Handeln, das Überschreiten von Gewinnzielen oder das Überschreiten von Verlustgrenzen verhindert wird – und das alles ohne bewusstes Eingreifen.
ConstraintManager manager; manager.AddConstraint(new TradeFrequencyConstraint(5)); manager.AddConstraint(new DailyProfitConstraint(2.0)); manager.AddConstraint(new DailyLossConstraint(3.0));
OnTradeTransaction() – Alle Beschränkungen in Echtzeit aktualisieren:
void OnTradeTransaction(const MqlTradeTransaction &trans, const MqlTradeRequest &request, const MqlTradeResult &result) { manager.UpdateAll(trans); }
Handelsausführung – Alle Orders werden über die Funktion „TryOpenOrder()“ abgewickelt, um die Regeln automatisch durchzusetzen.
Umfang, Filterung und Trade-Erfassung
Um Beschränkungen in einem Live-EA sinnvoll umzusetzen, ist es wichtig, den Umfang der Überwachung sowie die Art und Weise, wie Trades gezählt werden, festzulegen:
- Pro Symbol versus pro Konto: In dieser Implementierung erfasst jede Beschränkung Trades pro Symbol. EAs mit mehreren Symbolen würden für jedes Symbol separate Constraint-Instanzen oder eine zusätzliche Aggregationslogik erfordern.
- Manuelle Transaktionen: Standardmäßig können manuelle Trades, die außerhalb des EAs ausgeführt wurden, berücksichtigt werden, sofern sie von HistoryDealSelect erfasst werden. Andernfalls werden sie ignoriert. Das Framework ermöglicht es, auszuwählen, welche Transaktionen zu den Zählern beitragen.
- Filterung nach der MagicNumber: Beschränkungen können auf Positionen beschränkt werden, die unter einer bestimmten MagicNumber eröffnet wurden, wodurch Konflikte zwischen mehreren Strategien, die auf demselben Konto ausgeführt werden, vermieden werden.
Regeln für die Zählung von Trades:
- Es werden nur Markteinstiegsgeschäfte gezählt (DEAL_ENTRY_IN).
- Pending-Orders, Teilausführungen oder Ausstiegsgeschäfte werden nicht berücksichtigt, sofern sie nicht ausdrücklich in der Logik der Beschränkungen berücksichtigt sind.
//+------------------------------------------------------------------+ //| Minimal Enforcement EA (Testing Demo Only) | //+------------------------------------------------------------------+ #property strict input int MaxTradesPerDay = 2; int tradesToday = 0; datetime dayStartTime = 0; // Constraint Check Function bool TradeAllowed() { datetime today = iTime(_Symbol, PERIOD_D1, 0); if(today != dayStartTime) { tradesToday = 0; dayStartTime = today; } if(tradesToday >= MaxTradesPerDay) { Print("Trade blocked: Daily limit reached"); return false; } return true; } // Trade Gateway bool TryOpenOrder(MqlTradeRequest &request, MqlTradeResult &result) { if(!TradeAllowed()) return false; if(!OrderSend(request,result)) { Print("OrderSend failed: ", result.comment); return false; } tradesToday++; Print("Trade executed successfully"); return true; } // OnTick - test opening trades (demo only; in production, trigger on signals not every tick) void OnTick() { if(MathRand() % 1000 != 0) return; // Random throttle for safe testing; remove in real EA MqlTradeRequest req; MqlTradeResult res; ZeroMemory(req); ZeroMemory(res); // Example market buy request req.action = TRADE_ACTION_DEAL; req.symbol = _Symbol; req.volume = 0.1; req.type = ORDER_TYPE_BUY; req.price = SymbolInfoDouble(_Symbol,SYMBOL_ASK); req.magic = 123456; TryOpenOrder(req,res); } //+------------------------------------------------------------------+ //+------------------------------------------------------------------+
Umfang und Zielgruppe
Diese Serie stellt weder eine Handelsstrategie vor, noch prognostiziert sie die Marktrichtung, noch verfeinert sie Einstiegs- und Ausstiegstechniken. Sie ist jedoch nicht dazu gedacht, das Urteilsvermögen des Traders zu ersetzen oder die Ermessensentscheidungen zu automatisieren. Sein Anwendungsbereich ist bewusst auf ein einziges Ziel ausgerichtet: die strukturelle Durchsetzung der Handelsdisziplin.
Das zentrale Ziel besteht darin, Steuerungsebenen zu entwickeln – implementiert in MQL5 –, die mit jedem Handelsansatz kompatibel sind, sei es diskretionär, automatisiert oder hybrid. Diese Ebenen überwachen das Verhalten in Echtzeit, setzen vordefinierte Risikogrenzen durch und greifen konsequent ein, wenn diese Grenzen überschritten werden. Es handelt sich nicht um Trading-Engines. Sie generieren keine Signale, verwalten keine Positionen und führen keine Handelsgeschäfte aus. Ihr einziger Zweck besteht darin, objektive Rahmenbedingungen in das Handelsumfeld zu integrieren und so genau dort für mehr Struktur zu sorgen, wo menschliche Entscheidungen am anfälligsten für Druck sind.
Die Serie richtet sich in erster Linie an zwei Zielgruppen:
- Erfahrene Trader, die die Marktstruktur und die Orderausführung verstehen, aber unter realen Marktbedingungen mehr Konsistenz und einen besseren Kapitalschutz anstreben.
- Entwickler und technisch versierte Trader, die daran interessiert sind, Mechanismen zur Verhaltenssteuerung und Risikosteuerung in ihre bestehenden Systeme zu integrieren.
Es werden grundlegende Kenntnisse der Handelsprinzipien sowie erste Erfahrungen mit der MQL5-Programmierung vorausgesetzt. Es sind weder fortgeschrittene quantitative Modellierungen noch komplexe mathematische Konzepte erforderlich. Der Schwerpunkt liegt durchgehend auf praktischen und architektonischen Aspekten – es wird aufgezeigt, wie eine disziplinierte Umsetzung durch eine bewusste Systemgestaltung gestärkt werden kann, anstatt sich ausschließlich auf Impulskontrolle oder psychische Belastbarkeit zu verlassen.
Schlussfolgerung
Dieser Artikel hat gezeigt, wie Disziplin direkt in eine MQL5-Handelsumgebung integriert werden kann. Anstatt uns auf das Bewusstsein oder die Willenskraft zu verlassen, haben wir die diskretionären Regeln in messbare Beschränkungen, eine Echtzeitüberwachung und eine zentralisierte Durchsetzungsinstanz umgesetzt, die die Ausführung blockiert, sobald Grenzwerte überschritten werden.
Handelsfrequenzbegrenzungen, täglicher Gewinnschutz und Verlustbegrenzung wurden von schriftlichen Vorgaben in eine durchsetzbare Systemlogik umgesetzt. Alle Handelsvorgänge werden über TryOpenOrder() abgewickelt, wodurch sichergestellt wird, dass Verstöße keine Warnungen auslösen – sie verhindern vielmehr die Ausführung. Das Ergebnis ist strukturelle Disziplin.
Nach der Implementierung dieses Frameworks profitieren Sie von folgenden Vorteilen:
- Festgelegte und durchsetzbare Handelsbeschränkungen
- Ein zentralisiertes Blocking-Gateway für die Auftragsausführung
- Eine modulare Vorlage für einen Constraint-Manager zur skalierbaren Kontrolle
- Eindeutige Zähl- und Erfassungslogik für Trades und die täglichen Rücksetzungen
- Eine Ausführungsumgebung, in der Disziplin bereits in der Konzeption verankert ist
Dieses Framework hat keinen Einfluss auf die Strategielogik. Es stärkt diese, indem es die Umsetzungslücke zwischen Planung und praktischer Umsetzung schließt. Im nächsten Teil dieser Reihe werden wir diese Architektur um weiterführende Steuerungsebenen erweitern und dabei aufzeigen, wie sich strukturelle Kontrollmechanismen parallel zu den Handelssystemen weiterentwickeln können, ohne die Entwicklung der Kernstrategien zu beeinträchtigen.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/21273
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.
Entwicklung eines Toolkits zur Price-Action-Analyse (Teil 60): Objektive Swing-basierte Trendlinien für die Strukturanalyse
Larry Williams’ Marktgeheimnisse (Teil 10): Automatisierung von „Smash-Day“-Umkehrmustern in MQL5
Eine alternative Log-datei mit der Verwendung der HTML und CSS
Entwicklung eines Toolkits zur Price-Action-Analyse (Teil 59): Einsatz geometrischer Asymmetrie zur Erkennung präziser Ausbrüche aus fraktalen Konsolidierungsphasen
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.