Benutzerdefinierte Benachrichtigungen

Die API für benutzerdefinierte Benachrichtigungen umfasst Typen, die es Handelsalgorithmen ermöglichen, Echtzeit-Popup-Warnungen direkt in cTrader zu übermitteln. Diese Popups ermöglichen es cBots, Indikatoren und Plugins, Fortschritt, Erfolg, Fehler oder allgemeine Informationen visuell und kontextbezogen an Benutzer zu kommunizieren.

Mit der Unterstützung der API für benutzerdefinierte Benachrichtigungen müssen sich cBots für die Kommunikation nicht mehr auf die Registerkarte Protokoll, Chart-Objekte oder externe Telegram-Bridges verlassen. Algos teilen Händlern einfach direkt über das Standard-Benachrichtigungssystem in cTrader mit, was geschieht. Algorithmus-Entwickler und Benutzer profitieren von Geschwindigkeit, Zuverlässigkeit und Klarheit ohne komplexe Einrichtungen.

Zu den relevanten API-Schnittstellen gehören:

• INotifications.ShowPopup(caption, message, state) zur Anzeige einer Popup-Benachrichtigung mit einem bestimmten Titel, einer Nachricht und einem Status (PopupNotificationState).
• Schnittstelle PopupNotification für die programmgesteuerte Steuerung lang laufender oder progressiver Benachrichtigungen durch Aufrufen von .Complete(), um deren endgültigen Status zu aktualisieren.

Die von der API für benutzerdefinierte Benachrichtigungen übermittelten Nachrichten erscheinen sofort, sind nach Status farbcodiert und können später abgeschlossen werden. Die Benachrichtigungsstatus werden mithilfe der Enumeration PopupNotificationState definiert:

• InProgress zur Darstellung lang laufender Prozesse oder ausstehender Status. Beispiel:

  

• Success zur Anzeige, dass ein Vorgang erfolgreich abgeschlossen wurde. Beispiel:

  

• Error zur Signalisierung eines Fehlers oder einer Ausnahme. Beispiel:

  

• Partial zur Kommunikation eines teilweise erfolgreichen Ergebnisses (z. B. einige Orders waren erfolgreich). Beispiel:

  

• Information für allgemeine Warnungen, Aktualisierungen oder Rückmeldungen. Beispiel:

  

Benachrichtigungs-API-Objekte können für Folgendes verwendet werden:

Grundlegendes Beispiel

Wenn eine Instanz dieses cBots zu einem Chart hinzugefügt wird, stellt sie fünf Buttons bereit, einen pro Benachrichtigungsstatus. Durch Klicken auf einen Button wird eine Popup-Benachrichtigung ausgelöst.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class PopupNotificationStatesDemo : Robot
    {
        protected override void OnStart()
        {
            var panel = new StackPanel
            {
                Orientation = Orientation.Vertical,
                HorizontalAlignment = HorizontalAlignment.Center,
                VerticalAlignment = VerticalAlignment.Center
            };

            // InProgress
            var inProgressBtn = new Button { Text = "Show: InProgress", Margin = 5 };
            inProgressBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "In progress",
                    "Starting a long-running task…",
                    PopupNotificationState.InProgress
                );
            };
            panel.AddChild(inProgressBtn);

            // Success
            var successBtn = new Button { Text = "Show: Success", Margin = 5 };
            successBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "Success",
                    "The operation completed successfully.",
                    PopupNotificationState.Success
                );
            };
            panel.AddChild(successBtn);

            // Error
            var errorBtn = new Button { Text = "Show: Error", Margin = 5 };
            errorBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "Error",
                    "Something went wrong. Please check the logs or try again.",
                    PopupNotificationState.Error
                );
            };
            panel.AddChild(errorBtn);

            // Partial
            var partialBtn = new Button { Text = "Show: Partial", Margin = 5 };
            partialBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "Partial result",
                    "Completed with partial success (e.g. some orders filled).",
                    PopupNotificationState.Partial
                );
            };
            panel.AddChild(partialBtn);

            // Information
            var infoBtn = new Button { Text = "Show: Information", Margin = 5 };
            infoBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "Information",
                    "General update: your settings were saved.",
                    PopupNotificationState.Information
                );
            };
            panel.AddChild(infoBtn);

            Chart.AddControl(panel);
        }

        protected override void OnTick()
        {
            // Handle price updates here if needed
        }

        protected override void OnStop()
        {
            // Cleanup if needed
        }
    }
}

Orderverfolgung und Rückmeldung

Rückmeldung zur Orderausführung anzeigen

Verwenden Sie Popup-Benachrichtigungen, um sofort zu sehen, ob Ihre Market-Order erfolgreich war oder nicht. Wenn Ihr cBot beispielsweise eine Kauforder platziert, zeigt er ein Erfolgs-Popup an, wenn Ihre Transaktion abgeschlossen wurde, oder ein Fehler-Popup, wenn Ihr Broker sie abgelehnt hat.

1
2
3

var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000);
var state = result.IsSuccessful ? PopupNotificationState.Success : PopupNotificationState.Error;
Notifications.ShowPopup("Order Execution", $"Order result: {result.Error}", state);

TP- oder SL-Ausstiege bestätigen

Lassen Sie sich benachrichtigen, wenn Ihre cBot-Transaktion aufgrund von Take-Profit oder Stop-Loss beendet wird. Ein Popup zeigt den Ausstiegsgrund zusammen mit dem Gewinn oder Verlust aus der geschlossenen Position an. Diese Echtzeit-Rückmeldung zum Zeitpunkt des Ausstiegs hilft Ihnen, Transaktionen zu verfolgen und über die Ergebnisse Ihrer aktiven Positionen auf dem Laufenden zu bleiben.

1
2
3
4
5
6

protected override void OnPositionClosed(PositionClosedEventArgs args)
{
    var pos = args.Position;
    var reason = pos.ClosingReason.ToString();
    Notifications.ShowPopup("Position Closed", $"Closed due to {reason}. PnL: {pos.GrossProfit}", PopupNotificationState.Information);
}

Änderungen des Trailing-Stops verfolgen

Sehen Sie jedes Mal ein Popup, wenn ein Trailing-Stop den Stop-Loss für Ihre Position aktualisiert. Die Benachrichtigung enthält den neuen Stop-Loss-Wert und zeigt, wie der Trailing-Stop die Kursbewegung verfolgt. Diese Warnungen ermöglichen es Ihnen, zu überwachen, wie sich Ihr Handelsschutz anpasst, ohne ein Panel zu öffnen.

1
2
3
4
5
6
7

protected override void OnPositionModified(PositionModifiedEventArgs args)
{
    if (args.Reason == PositionModificationReason.TrailingStop)
    {
        Notifications.ShowPopup("Trailing Stop Moved", $"New SL: {args.Position.StopLoss}", PopupNotificationState.Information);
    }
}

Risiko- und regelbasierte Warnungen

Vor niedrigen Margin-Höhen warnen

Erhalten Sie eine Popup-Warnung, wenn die Margin-Höhe Ihres Kontos unter einen kritischen Schwellenwert fällt (z. B. 80 %). Die Warnung hilft Ihnen, rechtzeitig Maßnahmen zu ergreifen, wie z. B. das Schließen von Positionen oder das Hinzufügen von Geldmitteln, um eine erzwungene Liquidation oder eine Nachschussforderung zu vermeiden. Das Popup fungiert als automatisierte Schutzmaßnahme auf Grundlage von Echtzeit-Risikodaten.

1
2
3
4
5
6
7

protected override void OnTick()
{
    if (Account.MarginLevel < 80)
    {
        Notifications.ShowPopup("Low Margin Warning", $"Current margin level: {Account.MarginLevel:0.00}%", PopupNotificationState.Error);
    }
}

Warnungen für blockierte Transaktionen anzeigen

Einige cBots sind so programmiert, dass sie keine Transaktionen mehr platzieren, wenn interne Sicherheitsregeln wie niedriges Eigenkapital oder übermäßiger Drawdown ausgelöst werden. Ein Popup kann die Blockierung erklären und Ihnen zeigen, welche Bedingung verletzt wurde. Diese Benachrichtigung stellt sicher, dass Sie verstehen, warum ein Signal übersprungen wurde, und verstärkt ein diszipliniertes Strategieverhalten.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

protected override void OnBar()
{
    if (Account.Equity < 100)
    {
        Notifications.ShowPopup("Trade Blocked", "Equity too low to place trade", PopupNotificationState.Error);
        return;
    }

    ExecuteMarketOrder(TradeType.Sell, SymbolName, 1000);
}

Fortschritt und Diagnose

Analysefortschritt mit Popups anzeigen

Verwenden Sie ein InProgress-Popup, um den Start eines langwierigen Prozesses anzuzeigen, wie z. B. Datenvalidierung oder Vorbereitung für Backtesting. Sobald der Vorgang abgeschlossen ist, aktualisieren Sie das Popup auf den Status Success oder Error. Der angezeigte Fortschrittsbericht hält Sie auf dem Laufenden, ohne dass Sie Protokolle oder Debug-Meldungen überprüfen müssen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

private PopupNotification _progressPopup;

protected override void OnStart()
{
    _progressPopup = Notifications.ShowPopup("Analysis Started", "Running analysis...", PopupNotificationState.InProgress);
    Timer.Start(4); // Simulate 4-second task
}

protected override void OnTimer()
{
    _progressPopup.Complete(PopupNotificationState.Success);
    Timer.Stop();
}

Interaktionen beim manuellen Handeln

Benachrichtigen Sie Nutzer nach durch Buttons ausgelösten Transaktionen

Nachdem Sie auf ein benutzerdefiniertes Steuerelement oder einen Button geklickt haben, kann Ihr cBot eine Order platzieren und sofort ein Popup mit dem Ergebnis anzeigen. Die Benachrichtigung bestätigt, ob Ihre manuelle Aktion erfolgreich war oder fehlgeschlagen ist, und zeigt alle vom Broker zurückgegebenen Fehler an. Dieses visuelle Feedback reduziert Vermutungen und verbessert Ihr Vertrauen in manuelle Eingriffe.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

protected override void OnStart()
{
    var panel = new StackPanel();
    var button = new Button { Text = "Manual Buy" };

    button.Click += args =>
    {
        var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000);
        var status = result.IsSuccessful ? PopupNotificationState.Success : PopupNotificationState.Error;
        Notifications.ShowPopup("Manual Trade", $"Buy order result: {result.Error}", status);
    };

    panel.AddChild(button);
    Chart.AddControl(panel);
}

Warnen Sie vor manuellen Überschreibungen oder Eingriffen

Wenn Sie automatisierte Logik überschreiben oder eine manuelle Überschreibung durchführen (z. B. eine Transaktion in einem blockierten Zustand erzwingen), kann ein Popup die Aktion bestätigen.

1
2
3
4
5

button.Click += args =>
{
    Notifications.ShowPopup("Manual Override", "User manually triggered a trade", PopupNotificationState.Information);
    ExecuteMarketOrder(TradeType.Sell, SymbolName, 1000);
};

Marktereignisse und Signalalarme

Signalindikator-Crossovers

Überwachen Sie wichtige technische Ereignisse wie Moving-Average-Crossovers oder RSI-Schwellenwerte und zeigen Sie einen Popup-Alarm an, wenn diese auftreten. Die Benachrichtigung hebt den Indikator und die erfüllte Bedingung hervor, wie z. B. einen bullischen Crossover. Dies hält Sie über technische Signale auf dem Laufenden und macht Ihre Strategie transparenter und nachvollziehbarer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

private MovingAverage _fast, _slow;

protected override void OnStart()
{
    _fast = Indicators.MovingAverage(MarketSeries.Close, 5, MovingAverageType.Exponential);
    _slow = Indicators.MovingAverage(MarketSeries.Close, 20, MovingAverageType.Exponential);
}

protected override void OnBar()
{
    int i = MarketSeries.Close.Count - 1;
    if (_fast.Result[i] > _slow.Result[i] && _fast.Result[i - 1] <= _slow.Result[i - 1])
    {
        Notifications.ShowPopup("MA Crossover", "Fast MA crossed above Slow MA", PopupNotificationState.Information);
    }
}

Alarmieren Sie bei Handelszeitbeginn oder Kursspitzen

Erstellen Sie Popups, die ausgelöst werden, wenn wichtige Marktereignisse auftreten, wie z. B. die Eröffnung der Londoner Handelszeit oder eine schnelle Kursbewegung innerhalb eines kurzen Zeitraums. Diese Benachrichtigungen dienen als Situationsbewusstseins-Tools und helfen Ihnen, auf potenzielle Volatilität zu reagieren oder sich auf Marktaktivitäten vorzubereiten.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

protected override void OnBar()
{
    var time = Server.Time;
    if (time.TimeOfDay.Hours == 8 && time.TimeOfDay.Minutes == 0)
    {
        Notifications.ShowPopup("London Session Open", "London market has opened", PopupNotificationState.Information);
    }

    if (Math.Abs(Symbol.Bid - Symbol.Ask) / Symbol.PipSize > 15)
    {
        Notifications.ShowPopup("Spread Spike", "Spread exceeded 15 pips!", PopupNotificationState.Warning);
    }
}

Strategie-Debugging und Transparenz

Verfolgen Sie Strategieschritte visuell

Verwenden Sie eine Abfolge von Popups, um den logischen Ablauf Ihrer Strategie anzuzeigen. Zeigen Sie beispielsweise eine Meldung an, wenn der Trend überprüft, ein Signal bestätigt oder das Risiko validiert wird. Jedes Popup stellt einen bestimmten Kontrollpunkt dar, der es Ihnen ermöglicht, in Echtzeit zu verfolgen, wie die Strategie Entscheidungen trifft.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

protected override void OnBar()
{
    Notifications.ShowPopup("Step 1", "Checking market condition", PopupNotificationState.Information);

    if (MarketSeries.Close.Last(1) > MarketSeries.Open.Last(1))
    {
        Notifications.ShowPopup("Step 2", "Bullish candle detected", PopupNotificationState.Information);
    }

    Notifications.ShowPopup("Step 3", "Trade logic complete", PopupNotificationState.Success);
}

Melden Sie Logikfehler oder unerwartete Daten

Wenn Ihre Strategie auf einen Fehler oder ungültige Daten stößt, wie z. B. eine Kursdiskrepanz oder einen nicht verfügbaren Indikator, verwenden Sie ein Popup, um das genaue Problem anzuzeigen. Diese Einrichtung hilft Ihnen, Bugs oder Datenlücken während der Entwicklung und des Demo-/Live-Handels zu identifizieren, was zu schnellerem Debugging und robusterer Logik führt.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

protected override void OnBar()
{
    try
    {
        // Assume some strategy logic
        if (Symbol.Bid < 0) throw new Exception("Invalid price feed");

        Notifications.ShowPopup("Logic OK", "Price validation passed", PopupNotificationState.Success);
    }
    catch (Exception ex)
    {
        Notifications.ShowPopup("Logic error", ex.Message, PopupNotificationState.Error);
    }
}