Fehlertoleranz

Der Begriff „Fehlertoleranz" bezieht sich auf die Fähigkeit eines automatisierten Systems, bei einem Ausfall weiter zu funktionieren. Für cTrader-Algos bedeutet Fehlertoleranz, dass Prozesse, die cBots, Plugins und Indikatoren hosten, auch bei Fehlern weiterlaufen können.

Dieser Artikel erklärt, wie Fehlertoleranz funktioniert, und beschreibt die wichtigsten Vorteile, die diese Funktion Algo-Händlern bietet.

Fehlertoleranzregeln

Kurz gesagt stellt die Fehlertoleranz sicher, dass alle Algos die unten aufgeführten Regeln befolgen:

• Wenn ein Algo auf eine Ausnahme stößt, muss er weiterlaufen.
• Jede Ausnahme, die während des Betriebs eines Algos auftritt, muss protokolliert werden.
• Benutzer müssen die Möglichkeit haben, benutzerdefinierte Regeln einzuführen, die bestimmen, wie Algos mit verschiedenen Ausnahmen umgehen.

Die Fehlertoleranz ermöglicht es Algos, im Wesentlichen alle Fehler zu ignorieren, die nicht drohen, ihre Prozesse zum Absturz zu bringen. Während Ausnahmen möglicherweise immer noch die Code-Ausführung verhindern können, reduziert die Fehlertoleranz die Anzahl der Fälle, in denen ein Algo unerwartet abstürzen kann, erheblich.

Die Methode OnException()

Nach den Regeln der Fehlertoleranz müssen Algos Ausnahmen ignorieren. Sie können jedoch auch anpassen, wie Ihre Algos auf bestimmte Ausnahmen reagieren, oder die standardmäßigen Fehlertoleranzverhalten vollständig überschreiben.

Verwenden Sie dazu die Methode OnException(). Sie fungiert als dedizierter Handler für alle nicht behandelten Ausnahmen. Ihre Standardsignatur lautet wie folgt:

1
2
3
4

protected virtual void OnException(Exception exception)
{
    /// Introduce your custom exception handling logic here.
}

Betrachten Sie das folgende Beispiel, in dem die Methode OnException() verwendet wird, um zu ändern, wie ein cBot auf die Ausnahme NullReferenceException reagiert.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class SampleExceptionBot : Robot
    {
        private const string label = "Sample Exception Bot";
        protected override void OnStart()
        {
                var shortPosition = Positions.Find(label, SymbolName, TradeType.Sell);
                ClosePosition(shortPosition);
        }

        protected override void OnException(Exception exception)
        {
            if (exception is NullReferenceException)
            {
                MessageBox.Show("The position does not exist", "Error!");
            }
        }
    }
}

Um die Ausnahme NullReferenceException auszulösen, lassen wir unseren cBot eine Short-Position schließen, die möglicherweise nicht existiert. Wenn unser cBot auf die angegebene Ausnahme stößt, soll er eine MessageBox mit erläuterndem Text anzeigen, damit wir schnell auf diese Ausnahme reagieren und das Verhalten unseres cBots anpassen können.

Beachten Sie, dass der Handler OnException() nicht dazu gedacht ist, Ausnahmen zu behandeln, die auftreten, während diese Methode aufgerufen wird. Dennoch werden solche Ausnahmen weiterhin im Ereignisprotokoll aufgezeichnet.

Vorteile der Fehlertoleranz

Fehlertoleranz ist ein entscheidender Aspekt der Funktionsweise des Algo-Handels in cTrader, da sie die folgenden Vorteile bietet.

• Die Fehlertoleranz steigert die Zuverlässigkeit von Algos erheblich und bietet neue Möglichkeiten zur Verfeinerung Ihres Ansatzes beim automatisierten Handel.
• Da Algos die Ausnahmen, auf die sie stoßen, im Ereignisprotokoll anzeigen können, können Sie leicht die Bedingungen ermitteln, unter denen ein Algo auf einen bestimmten Fehler gestoßen ist.
• Durch die Ermöglichung der Behandlung von Ausnahmeereignissen kann die Methode OnException() verwendet werden, um das Verhalten Ihrer Algos zu perfektionieren und ihre Zuverlässigkeit zu verbessern.

Abstürze behandeln

Wie bereits erwähnt, können mehrere Fehler ganze Prozesse zum Absturz bringen. Sie lauten wie folgt:

• Die Ausnahme OutOfMemoryException.
• Die Ausnahme StackOverflowException.
• Jede nicht behandelte Ausnahme, die in einem separaten Thread auftritt.
• Alle anderen Fehler, die drohen könnten, den Prozess zum Absturz zu bringen, in dem ein Algo ausgeführt wird.

Wenn eine Indikatorinstanz auf einen der oben genannten Fehler stößt, wird sie gestoppt; sie wird nicht automatisch neu gestartet. Die Ausnahme wird jedoch weiterhin im Protokoll aufgezeichnet.

Im Gegensatz dazu wird ein Prozess, der eine cBot-Instanz hostet, bei einem Absturz automatisch neu gestartet (wobei die Ausnahme im Protokoll aufgezeichnet wird).

Zusammenfassung

Die Fehlertoleranz bietet mehrere wertvolle Möglichkeiten, um Algos noch stabiler und effektiver zu machen. Der Handler OnException() bietet eine zusätzliche Kontrollebene darüber, wie Ihre Algos auf Ausnahmen reagieren.