Vai al contenuto

Notifiche personalizzate

L'API delle notifiche personalizzate include tipi che consentono agli algoritmi di trading di fornire avvisi popup in tempo reale direttamente in cTrader. Questi popup consentono a cBot, indicatori e plugin di comunicare agli utenti progressi, successi, errori o informazioni generali in modo visivo e contestuale.

Con il supporto dell'API delle notifiche personalizzate, i cBot non devono più affidarsi alla scheda Registro, agli oggetti del grafico o ai bridge Telegram esterni per la comunicazione. Gli algoritmi semplicemente comunicano ai trader ciò che sta accadendo direttamente tramite il sistema di notifiche standard in cTrader. Gli sviluppatori di algoritmi e gli utenti beneficiano di velocità, affidabilità e chiarezza senza configurazioni complesse.

Le interfacce API rilevanti includono:

  • INotifications.ShowPopup(caption, message, state) per visualizzare una notifica popup con un determinato titolo, messaggio e stato (PopupNotificationState).
  • Interfaccia PopupNotification per il controllo programmatico di notifiche di lunga durata o progressive chiamando .Complete() per aggiornare il loro stato finale.

I messaggi forniti dall'API delle notifiche personalizzate appaiono istantaneamente, sono codificati per colore in base allo stato e possono essere completati successivamente. Gli stati delle notifiche sono definiti utilizzando l'enum PopupNotificationState:

  • InProgress per rappresentare processi di lunga durata o stati in sospeso. Esempio:

  • Success per indicare che un'operazione è stata completata con successo. Esempio:

  • Error per segnalare un errore o un'eccezione. Esempio:

  • Partial per comunicare un risultato parzialmente riuscito (ad es. alcuni ordini sono andati a buon fine). Esempio:

  • Information per avvisi generali, aggiornamenti o feedback. Esempio:

Suggerimento

Utilizza le notifiche popup per monitorare l'attività di trading, eseguire il debug dei flussi logici, avvisare gli utenti di eventi di mercato o errori nei dati e fornire feedback dinamici dell'interfaccia utente durante operazioni di strategia live o manuali.

Gli oggetti dell'API Notifications possono essere utilizzati per eseguire le seguenti operazioni:

Funzionalità o operazione Esempi
Monitoraggio degli ordini e feedback Visualizza il feedback sull'esecuzione degli ordini
Conferma le uscite TP/SL
Monitora le modifiche dello stop trailing
Avvisi basati su rischio e regole Avvisa di livelli di margine bassi
Mostra avvisi per operazioni bloccate
Progressi e diagnostica Mostra i progressi dell'analisi con popup
Interazioni di trading manuale Fornisci feedback per le azioni di trading
Avvisa di sostituzioni o interventi manuali
Eventi di mercato e avvisi di segnale Segnala incroci di indicatori
Annuncia aperture di sessione o picchi di prezzo
Debug e trasparenza della strategia Traccia visivamente i passaggi della strategia/logica
Segnala errori logici

Esempio di base

Quando un'istanza di questo cBot viene aggiunta a un grafico, fornisce cinque pulsanti, uno per stato di notifica. Facendo clic su un pulsante si attiva una notifica popup.

 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
        }
    }
}

Monitoraggio degli ordini e feedback

Visualizza il feedback sull'esecuzione degli ordini

Utilizza le notifiche popup per vedere istantaneamente se il tuo ordine di mercato ha avuto successo o meno. Ad esempio, dopo che il tuo cBot ha piazzato un ordine di acquisto, mostra un popup di successo se la tua operazione è stata eseguita o un popup di errore se il tuo broker l'ha rifiutata.

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);

Conferma le uscite TP o SL

Ricevi una notifica quando la tua operazione del cBot esce a causa di take-profit o stop-loss. Un popup mostra il motivo dell'uscita insieme al profitto o alla perdita dalla posizione chiusa. Questo feedback in tempo reale al momento dell'uscita ti aiuta a monitorare le operazioni e a rimanere aggiornato sui risultati delle tue posizioni attive.

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);
}

Tieni traccia delle modifiche al trailing stop

Visualizza un popup ogni volta che un trailing stop aggiorna lo stop loss per la tua posizione. La notifica include il nuovo valore dello stop loss e mostra come il trailing stop sta seguendo l'azione del prezzo. Questi avvisi ti permettono di monitorare come la protezione della tua operazione si adatta senza dover aprire alcun riquadro.

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);
    }
}

Avvisi basati su rischio e regole

Avvisa in caso di livelli di margine bassi

Ricevi un avviso popup quando il livello di margine del tuo conto scende al di sotto di una soglia critica (ad es. 80%). L'avviso ti aiuta a intraprendere azioni tempestive, come chiudere posizioni o aggiungere fondi, per evitare la liquidazione forzata o una richiesta di margine. Il popup funge da salvaguardia automatizzata basata su dati di rischio in tempo reale.

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);
    }
}

Mostra avvisi per operazioni bloccate

Alcuni cBot sono programmati per interrompere il piazzamento di operazioni quando vengono attivate regole di sicurezza interne, come capitale netto basso o drawdown eccessivo. Un popup può spiegare il blocco e mostrarti quale condizione è stata violata. Questa notifica ti assicura di comprendere perché un segnale è stato saltato e rafforza il comportamento disciplinato della strategia.

 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);
}

Avanzamento e diagnostica

Mostra l'avanzamento dell'analisi con popup

Usa un popup InProgress per indicare l'inizio di un processo di lunga durata, come la convalida dei dati o la preparazione per il backtesting. Una volta completata l'operazione, aggiorna il popup allo stato Success o Error. Il rapporto di avanzamento visualizzato ti tiene informato senza dover controllare i log o i messaggi di debug.

 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();
}

Interazioni di trading manuale

Notifica gli utenti dopo operazioni attivate da pulsante

Dopo aver cliccato su un controllo personalizzato o un pulsante, il tuo cBot può piazzare un ordine e mostrare immediatamente un popup con il risultato. La notifica conferma se la tua azione manuale è riuscita o fallita e visualizza eventuali errori restituiti dal broker. Questo feedback visivo riduce le congetture e migliora la tua fiducia negli interventi manuali.

 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);
}

Avvisa in caso di override manuali o interventi

Quando esegui l'override della logica automatizzata o effettui un override manuale (ad es. forzi un'operazione durante uno stato bloccato), un popup può confermare l'azione.

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

Eventi di mercato e avvisi sui segnali

Segnala incroci di indicatori

Monitora eventi tecnici chiave come incroci di medie mobili o soglie RSI e mostra un avviso popup quando si verificano. La notifica evidenzia l'indicatore e la condizione soddisfatta, come un incrocio rialzista. Questo ti tiene informato sui segnali tecnici e rende la tua strategia più trasparente e tracciabile.

 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);
    }
}

Avvisa aperture di sessione o picchi di prezzo

Crea popup che si attivano quando si verificano eventi di mercato importanti, come l'apertura della sessione di Londra o un rapido movimento di prezzo in un breve periodo. Queste notifiche fungono da strumenti di consapevolezza situazionale e ti aiutano a reagire alla potenziale volatilità o a prepararti per l'attività di mercato.

 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);
    }
}

Debug e trasparenza della strategia

Traccia visivamente i passaggi della strategia

Usa una sequenza di popup per mostrare il flusso logico della tua strategia. Ad esempio, visualizza un messaggio quando controlli il trend, confermi un segnale o convalidi il rischio. Ogni popup rappresenta un checkpoint specifico, che ti permette di seguire come la strategia prende decisioni in tempo reale.

 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);
}

Segnala errori logici o dati imprevisti

Quando la tua strategia incontra un errore o dati non validi, come una discrepanza di prezzo o un indicatore non disponibile, usa un popup per mostrare il problema esatto. Questa configurazione ti aiuta a identificare bug o lacune nei dati durante lo sviluppo e il trading demo/live, risultando in un debug più rapido e una logica più resiliente.

 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);
    }
}