Modelli di grafico

La raccolta ChartTemplates e gli oggetti ChartTemplate consentono di salvare, gestire e applicare in modo programmatico i template dei grafici, senza dover gestire configurazioni manuali. Questa funzionalità è utile per:

Trader che vogliono che gli algoritmi configurino e gestiscano layout di grafici coerenti, cambio fluido di template, acquisizione e archiviazione delle impostazioni, monitoraggio e altro ancora.
Sviluppatori che necessitano di ambienti di grafici ripetibili per analisi avanzate, monitoraggio, debug o distribuzione di indicatori di supporto e cBot su molti grafici.

Concetti fondamentali

Un singolo ChartTemplate espone:

template.Apply(Chart) per applicare un template a un grafico di destinazione.
template.Indicators per aggiungere o rimuovere indicatori, accedere ai loro parametri.
template.Robots per aggiungere o rimuovere cBot.
template.ColorSettings per lavorare con i colori del grafico o del tema
template.DisplaySettings per lavorare con il tipo di grafico, lo zoom e vari interruttori, inclusi posizioni, ordini, griglia, sentiment e altro ancora.

L'oggetto ChartTemplates, una raccolta integrata, fornisce:

foreach (var t in ChartTemplates) ... per l'enumerazione.
ChartTemplates.Get(name), ChartTemplates.Contains(name) per le query.
ChartTemplates.Create(name) per creare template vuoti.
ChartTemplates.Create(name, Chart) per acquisire la configurazione corrente del grafico.
ChartTemplates.Duplicate(newName, sourceTemplate) per duplicare i template.
ChartTemplates.Remove(template) per rimuovere i template.
ChartTemplates.DefaultTemplate per applicare il template predefinito (get o set).

Espone anche eventi:

ChartTemplates.Added += ...
ChartTemplates.Removed += ...

La tabella seguente fornisce un riepilogo delle operazioni standard.

Operazione	Esempi
Ciclo di vita del template	Crea un template vuoto Crea un template dal grafico corrente Duplica un template Rimuovi un template
Individuazione dei template	Elenca i template e mostra i dati Verifica se un template esiste Reagisci all'aggiunta o alla rimozione di un template
Applicazione dei template	Applica un template a un grafico Modifica il template predefinito
Composizione dei template	Aggiungi o rimuovi un indicatore Modifica i parametri di un indicatore Aggiungi o rimuovi un cBot
Impostazioni di layout e visualizzazione	Imposta i colori del grafico Abilita o disabilita le opzioni di visualizzazione del grafico Modifica il tipo di grafico Regola il livello di zoom

Considera un cBot Chart Templates Manager che, una volta aggiunto e avviato su un grafico, visualizza un menu per eseguire varie attività con i template dei grafici.

Visualizzazione predefinitaSelezione dei templateScelta degli indicatoriAggiunta di cBot

Codice

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

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class ChartTemplatesManager : Robot
    {
        protected override void OnStart()
        {
            var templatesComboBox = new ComboBox();

            templatesComboBox.AddItem("Click to view available templates");
            templatesComboBox.SelectedItem = "Click to view available templates";

            foreach (var template in ChartTemplates)
            {
                templatesComboBox.AddItem(template.Name);
            }

            ChartTemplates.Added += args =>
            {
                templatesComboBox.AddItem(args.ChartTemplate.Name);
                Print($"A new template was added: {args.ChartTemplate.Name}");
            };

            ChartTemplates.Removed += args =>
            {
                templatesComboBox.RemoveItem(args.ChartTemplate.Name);
                Print($"A template was removed: {args.ChartTemplate.Name}");
            };

            var showTemplateInfoButton = new Button { Text = "Show the template information" };

            showTemplateInfoButton.Click += args =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                Print($"Name: {template.Name} | Bots #: {template.Robots.Count} | Indicators #: {template.Indicators.Count}");
            };

            var showDefaultTemplateInfoButton = new Button { Text = "Show the default template information" };

            showDefaultTemplateInfoButton.Click += args =>
            {
                Print($"Name: {ChartTemplates.DefaultTemplate.Name} | Bots #: {ChartTemplates.DefaultTemplate.Robots.Count} | Indicators #: {ChartTemplates.DefaultTemplate.Indicators.Count}");
            };

            var removeTemplateButton = new Button { Text = "Remove the selected template" };

            removeTemplateButton.Click += _ => ChartTemplates.Remove(ChartTemplates.Get(templatesComboBox.SelectedItem));

            var applyTemplateButton = new Button { Text = "Apply the selected template" };

            applyTemplateButton.Click += _ => ChartTemplates.Get(templatesComboBox.SelectedItem).Apply(Chart);

            var duplicateTemplateButton = new Button { Text = "Duplicate the selected template" };

            duplicateTemplateButton.Click += _ => ChartTemplates.Duplicate($"{templatesComboBox.SelectedItem} Duplicate", ChartTemplates.Get(templatesComboBox.SelectedItem));

            var createTemplateTextBox = new TextBox { Text = "Click to type in a template name" };

            var createEmptyTemplateButton = new Button { Text = "Create an empty template" };

            createEmptyTemplateButton.Click += _ => ChartTemplates.Create(createTemplateTextBox.Text);

            var createTemplateBasedOnChartButton = new Button { Text = "Create a template from the current chart" };

            createTemplateBasedOnChartButton.Click += _ => ChartTemplates.Create(createTemplateTextBox.Text, Chart);

            var changeDefaultTemplateToSelectedButton = new Button { Text = "Set the selected template as the default" };

            changeDefaultTemplateToSelectedButton.Click += _ => ChartTemplates.DefaultTemplate = ChartTemplates.Get(templatesComboBox.SelectedItem);

            var checkSelectedTemplateExistsButton = new Button { Text = "Check whether the selected template exists" };

            checkSelectedTemplateExistsButton.Click += _ => Print($"The template '{templatesComboBox.SelectedItem}' exists: {ChartTemplates.Contains(templatesComboBox.SelectedItem)}");

            var removeSelectedTemplateIndicator = new Button { Text = "Remove an indicator from the selected template" };

            removeSelectedTemplateIndicator.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                if (template.Indicators.Count == 0)
                    return;

                Print($"Removal result: {template.Indicators.Remove(template.Indicators.First())}");
            };

            var removeSelectedTemplateBot = new Button { Text = "Remove a cBot from the selected template" };

            removeSelectedTemplateBot.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                if (template.Robots.Count == 0)
                    return;

                Print($"Removal result: {template.Robots.Remove(template.Robots.First())}");
            };


            var indicatorsCombobox = new ComboBox();

            indicatorsCombobox.AddItem("Click to select an indicator");
            indicatorsCombobox.SelectedItem = "Click to select an indicator";

            foreach (var indicator in AlgoRegistry.Indicators.OrderBy(i => i.Name))
            {
                indicatorsCombobox.AddItem(indicator.Name);
            }

            var addIndicatorWithDefaultParametersToSelectedTemplate = new Button { Text = "Add the selected indicator to the selected template using default parameters" };

            addIndicatorWithDefaultParametersToSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                if (string.IsNullOrWhiteSpace(indicatorsCombobox.SelectedItem))
                {
                    Print("No indicator is selected.");
                    return;
                }

                Print($"Added the indicator {indicatorsCombobox.SelectedItem}.");

                template.Indicators.Add(indicatorsCombobox.SelectedItem);
            };

            var robotsCombobox = new ComboBox();

            robotsCombobox.AddItem("Click to select a cBot");
            robotsCombobox.SelectedItem = "Click to select a cBot";

            foreach (var robot in AlgoRegistry.Robots.OrderBy(i => i.Name))
            {
                robotsCombobox.AddItem(robot.Name);
            }

            var addRobotWithDefaultParametersToSelectedTemplate = new Button { Text = "Add the selected cBot to the selected template using default parameters" };

            addRobotWithDefaultParametersToSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                if (string.IsNullOrWhiteSpace(robotsCombobox.SelectedItem))
                {
                    Print("No cBot is selected.");
                    return;
                }

                Print($"Added the cBot {robotsCombobox.SelectedItem}.");

                template.Robots.Add(robotsCombobox.SelectedItem);
            };

            var addEmaIndicatorWithDifferentParametersToSelectedTemplate = new Button { Text = "Add an EMA indicator to the selected template using custom parameters" };

            addEmaIndicatorWithDifferentParametersToSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                var emaType = AlgoRegistry.Get("Exponential Moving Average", AlgoKind.StandardIndicator) as IndicatorType;

                Print($"Added the indicator {emaType.Name} with a period of 100.");

                template.Indicators.Add(emaType, Bars.OpenPrices, 100);
            };

            var changeEmaIndicatorParametersForSelectedTemplate = new Button { Text = "Change the EMA indicator parameters in the selected template" };

            changeEmaIndicatorParametersForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                var emaType = AlgoRegistry.Get("Exponential Moving Average", AlgoKind.StandardIndicator) as IndicatorType;

                if (template.Indicators.FirstOrDefault(i => i.Type == emaType) is not { } templateIndicator)
                {
                    Print($"The EMA indicator was not found in the template '{template.Name}'.");
                    return;
                }

                Print($"Changing the indicator {emaType.Name} period to 200.");

                templateIndicator.Parameters["Periods"].Value = 200;
            };

            var setAllColorSettingsToRedForSelectedTemplate = new Button { Text = "Set all colour settings to red for the selected template" };

            setAllColorSettingsToRedForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.ColorSettings.AskPriceLineColor = Color.Red;
                template.ColorSettings.BidPriceLineColor = Color.Red;
                template.ColorSettings.BackgroundColor = Color.Red;
                template.ColorSettings.BearFillColor = Color.Red;
                template.ColorSettings.BearOutlineColor = Color.Red;
                template.ColorSettings.BullFillColor = Color.Red;
                template.ColorSettings.BullOutlineColor = Color.Red;
                template.ColorSettings.BuyColor = Color.Red;
                template.ColorSettings.ForegroundColor = Color.Red;
                template.ColorSettings.GridLinesColor = Color.Red;
                template.ColorSettings.LosingDealColor = Color.Red;
                template.ColorSettings.PeriodSeparatorColor = Color.Red;
                template.ColorSettings.SellColor = Color.Red;
                template.ColorSettings.TickVolumeColor = Color.Red;
                template.ColorSettings.WinningDealColor = Color.Red;
                template.ColorSettings.AreaFillColor = Color.Red;
            };

            var enableAllDisplayOptionsForSelectedTemplate = new Button { Text = "Enable all display options for the selected template" };

            enableAllDisplayOptionsForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.DisplaySettings.AskPriceLine = true;
                template.DisplaySettings.Bars = true;
                template.DisplaySettings.BidPriceLine = true;
                template.DisplaySettings.ChartScale = true;
                template.DisplaySettings.DealMap = true;
                template.DisplaySettings.Grid = true;
                template.DisplaySettings.IndicatorTitles = true;
                template.DisplaySettings.MarketSentiment = true;
                template.DisplaySettings.Orders = true;
                template.DisplaySettings.PeriodSeparators = true;
                template.DisplaySettings.Positions = true;
                template.DisplaySettings.PriceAlerts = true;
                template.DisplaySettings.PriceAxisOverlayButtons = true;
                template.DisplaySettings.QuickTradeButtons = true;
                template.DisplaySettings.Targets = true;
                template.DisplaySettings.TickVolume = true;
                template.DisplaySettings.AddRobotButton = true;
            };

            var disableAllDisplayOptionsForSelectedTemplate = new Button { Text = "Disable all display options for the selected template" };

            disableAllDisplayOptionsForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.DisplaySettings.AskPriceLine = false;
                template.DisplaySettings.Bars = false;
                template.DisplaySettings.BidPriceLine = false;
                template.DisplaySettings.ChartScale = false;
                template.DisplaySettings.DealMap = false;
                template.DisplaySettings.Grid = false;
                template.DisplaySettings.IndicatorTitles = false;
                template.DisplaySettings.MarketSentiment = false;
                template.DisplaySettings.Orders = false;
                template.DisplaySettings.PeriodSeparators = false;
                template.DisplaySettings.Positions = false;
                template.DisplaySettings.PriceAlerts = false;
                template.DisplaySettings.PriceAxisOverlayButtons = false;
                template.DisplaySettings.QuickTradeButtons = false;
                template.DisplaySettings.Targets = false;
                template.DisplaySettings.TickVolume = false;
                template.DisplaySettings.AddRobotButton = false;
            };

            var changeChartTypeForSelectedTemplate = new Button { Text = "Change the chart type for the selected template" };

            changeChartTypeForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.DisplaySettings.ChartType = template.DisplaySettings.ChartType switch
                {
                    ChartType.Area => ChartType.Bars,
                    ChartType.Bars => ChartType.Candlesticks,
                    ChartType.Candlesticks => ChartType.Dots,
                    ChartType.Dots => ChartType.Hlc,
                    ChartType.Hlc => ChartType.Line,
                    _ => ChartType.Area
                };

                Print($"Changed the template '{template.Name}' chart type to '{template.DisplaySettings.ChartType}'.");
            };

            var changeZoomeLevelForSelectedTemplate = new Button { Text = "Change the zoom level for the selected template" };

            changeZoomeLevelForSelectedTemplate.Click += _ =>
            {
                if (string.IsNullOrWhiteSpace(templatesComboBox.SelectedItem))
                {
                    Print("No template is selected.");
                    return;
                }

                var template = ChartTemplates.Get(templatesComboBox.SelectedItem);

                template.DisplaySettings.ZoomLevel = template.DisplaySettings.ZoomLevel switch
                {
                    5 => 400,
                    400 => 5,
                    _ => 5
                };

                Print($"Changed the template '{template.Name}' zoom level to '{template.DisplaySettings.ZoomLevel}'.");
            };

            var panel = new StackPanel { Orientation = Orientation.Vertical, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center };

            panel.AddChild(templatesComboBox);
            panel.AddChild(showTemplateInfoButton);
            panel.AddChild(showDefaultTemplateInfoButton);
            panel.AddChild(removeTemplateButton);
            panel.AddChild(applyTemplateButton);
            panel.AddChild(duplicateTemplateButton);
            panel.AddChild(createTemplateTextBox);
            panel.AddChild(createEmptyTemplateButton);
            panel.AddChild(createTemplateBasedOnChartButton);
            panel.AddChild(changeDefaultTemplateToSelectedButton);
            panel.AddChild(checkSelectedTemplateExistsButton);
            panel.AddChild(removeSelectedTemplateIndicator);
            panel.AddChild(removeSelectedTemplateBot);
            panel.AddChild(indicatorsCombobox);
            panel.AddChild(addIndicatorWithDefaultParametersToSelectedTemplate);
            panel.AddChild(robotsCombobox);
            panel.AddChild(addRobotWithDefaultParametersToSelectedTemplate);
            panel.AddChild(addEmaIndicatorWithDifferentParametersToSelectedTemplate);
            panel.AddChild(changeEmaIndicatorParametersForSelectedTemplate);
            panel.AddChild(setAllColorSettingsToRedForSelectedTemplate);
            panel.AddChild(enableAllDisplayOptionsForSelectedTemplate);
            panel.AddChild(disableAllDisplayOptionsForSelectedTemplate);
            panel.AddChild(changeChartTypeForSelectedTemplate);
            panel.AddChild(changeZoomeLevelForSelectedTemplate);

            Chart.AddControl(panel);
        }
    }
}

Applicazioni pratiche

Acquisisci la configurazione corrente

Sviluppa algoritmi che acquisiscono in modo programmatico le impostazioni di un grafico, inclusi indicatori, parametri, colori e altro, e le archiviano come template. Questo ti consente di preservare automaticamente una configurazione funzionante durante qualsiasi fase del trading algoritmico e di applicarla a qualsiasi altro grafico.

Questo codice C# dimostra un cBot che acquisisce e archivia il template di un grafico:

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

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class CaptureChartAsTemplate : Robot
    {
        [Parameter("Template Name", DefaultValue = "My Golden Layout")]
        public string TemplateName { get; set; }

        protected override void OnStart()
        {
            // If you want "overwrite", remove first (safe pattern).
            if (ChartTemplates.Contains(TemplateName))
            {
                var existing = ChartTemplates.Get(TemplateName);
                ChartTemplates.Remove(existing);
                Print($"Removed existing template '{TemplateName}' to recapture.");
            }

            // Capture everything from the CURRENT chart (indicators/robots/colors/display settings).
            var created = ChartTemplates.Create(TemplateName, Chart);

            Print($"Captured template '{created.Name}' from current chart. " +
                  $"Indicators={created.Indicators.Count}, Robots={created.Robots.Count}");
        }
    }
}

Crea aree di lavoro distinte

Struttura il tuo flusso di lavoro discrezionale in tre layout di grafici dedicati e passa da uno all'altro istantaneamente. Un flusso di lavoro discrezionale comune è:

Scansione – grafico minimale, caricamento veloce, candele pulite, nessun disordine.
Conferma – indicatori e sovrapposizioni di contesto, come filtri di tendenza/volatilità.
Esecuzione – mostra ordini/posizioni/obiettivi e pulsanti Quick Trade, nascondi tutto ciò che distrae.

private void ApplyWorkspace(string name)
{
    if (ChartTemplates.Contains(name))
        ChartTemplates.Get(name).Apply(Chart);
}

Standardizza il trading di tendenza

Quando fai trading di tendenza, in genere ti affidi a tre elementi fondamentali: un filtro di tendenza come una EMA, una misura di momentum o di ipercomprato-ipervenduto come l'RSI e un grafico a candele pulito con colori stabili e sovrapposizioni leggibili. Puoi salvare questa configurazione come un unico template e applicarla a qualsiasi simbolo o timeframe che apri.

Una configurazione standardizzata ti aiuta a evitare incongruenze nei parametri, ridurre gli errori di configurazione e garantire che ogni grafico segua lo stesso framework decisionale.

var t = ChartTemplates.Get("Trend Setup");

t.Indicators.Add("Relative Strength Index");

var emaType = AlgoRegistry.Get("Exponential Moving Average", AlgoKind.StandardIndicator) as IndicatorType;
t.Indicators.Add(emaType, Bars.OpenPrices, 200);

t.DisplaySettings.ChartType = ChartType.Candlesticks;
t.DisplaySettings.ZoomLevel = 200;

t.Apply(Chart);

Crea layout di mean-reversion

Quando fai trading di mean reversion, spesso ti affidi a un maggiore contesto di indicatori, ma vuoi comunque un grafico pulito e controllato. Usa i template per decidere esattamente cosa rimane visibile durante l'analisi.

Disattiva i pulsanti Quick Trade per prevenire ingressi accidentali. Nascondi il pannello del sentiment se ti distrae. Mantieni visibili la griglia e i livelli chiave per un posizionamento preciso. Scegli il tipo di grafico che corrisponde al tuo approccio, che si tratti di candele giapponesi per la struttura o di un grafico a linee per la chiarezza.

var mr = ChartTemplates.Get("Mean Reversion");

mr.DisplaySettings.QuickTradeButtons = false;
mr.DisplaySettings.MarketSentiment = false;
mr.DisplaySettings.Grid = true;
mr.DisplaySettings.Orders = true;
mr.DisplaySettings.Positions = true;

mr.Apply(Chart);

Crea template di monitoraggio

Quando sei in un'operazione, le tue priorità cambiano. Hai bisogno di una chiara visibilità delle posizioni aperte, degli ordini in sospeso e dei livelli obiettivo, insieme a una visualizzazione del grafico stabile e coerente. Mantieni fisso il livello di zoom, assicurati che le linee dei prezzi siano chiaramente visualizzate e rimuovi gli indicatori che non supportano direttamente le decisioni di gestione.

var monitor = ChartTemplates.Get("Monitor");

monitor.DisplaySettings.Positions = true;
monitor.DisplaySettings.Orders = true;
monitor.DisplaySettings.Targets = true;
monitor.DisplaySettings.PriceAlerts = true;

monitor.DisplaySettings.IndicatorTitles = false;   // reduce noise
monitor.DisplaySettings.ZoomLevel = 150;

monitor.Apply(Chart);

Applica standard visivi

Se lavori all'interno di un team o segui uno stile di postazione di lavoro definito, usa i template per standardizzare elementi come il colore di sfondo, i colori delle candele rialziste e ribassiste, la visibilità della griglia e lo stile delle linee. Applica lo stesso template a tutti i grafici per garantire una struttura visiva uniforme, ridurre la confusione e migliorare la comunicazione.

Questa configurazione diventa particolarmente importante quando condividi screenshot, conduci revisioni di strategie o trasferisci decisioni.

var style = ChartTemplates.Get("House Style");

style.ColorSettings.BackgroundColor = Color.Black;
style.ColorSettings.ForegroundColor = Color.White;
style.ColorSettings.GridLinesColor = Color.Gray;
style.ColorSettings.BullFillColor = Color.Green;
style.ColorSettings.BearFillColor = Color.Red;

style.Apply(Chart);

Aggiungi template di volatilità

Quando la volatilità cambia, le tue esigenze di esecuzione e analisi cambiano. Crea template per definire due aree di lavoro distinte e passa da una all'altra man mano che le condizioni evolvono:

Nel template a bassa volatilità, usa uno zoom più stretto, riduci le sovrapposizioni e mantieni una visualizzazione pulita adatta al trading di range.
Nel template ad alta volatilità, usa uno zoom più ampio, linee dei prezzi più chiare, abilita la griglia e visualizza posizioni e ordini per un controllo di esecuzione più stretto.

private void ApplyRegimeTemplate(bool highVol)
{
    var name = highVol ? "HighVol" : "LowVol";
    if (ChartTemplates.Contains(name))
        ChartTemplates.Get(name).Apply(Chart);
}

Crea contesti con un solo clic

Spesso usi parametri di indicatori, livelli di zoom e preferenze visive diversi a seconda che tu stia facendo scalping o swing trading. Invece di regolare manualmente le impostazioni ogni volta che cambi timeframe, crea template dedicati per ogni visualizzazione.

Ad esempio, definisci M1-Scalp per un'esecuzione rapida e uno zoom più stretto, M15-Intraday per il trading strutturato di sessione e H1-Swing per un contesto più ampio e sovrapposizioni più fluide.

private void ApplyTimeframeWorkspace(TimeFrame tf)
{
    var name =
        tf == TimeFrame.Minute ? "M1-Scalp" :
        tf == TimeFrame.Minute15 ? "M15-Intraday" :
        "H1-Swing";

    if (ChartTemplates.Contains(name))
        ChartTemplates.Get(name).Apply(Chart);
}

Crea playbook di strategie

Se fai trading con più famiglie di strategie, considera di definire un template dedicato per ogni playbook. Ad esempio, puoi:

Usare un template di playbook di breakout con la griglia abilitata, ordini e posizioni visibili, uno zoom più ampio e linee dei prezzi pulite per chiarezza nell'esecuzione.
Usare un template di playbook di pullback con EMA e RSI applicati, un livello di zoom normale e titoli degli indicatori visibili.
Usare un template di playbook di inversione con indicatori di contesto aggiuntivi e un tipo di candela che evidenzia gli stoppini e la struttura.

Con ogni playbook codificato come template, puoi cambiare ambiente in base al tipo di segnale e mantenere la tua esecuzione allineata con la strategia che stai applicando.

private void ApplyPlaybook(string playbook)
{
    var name = playbook switch
    {
        "Breakout" => "Breakout Playbook",
        "Pullback" => "Pullback Playbook",
        "Reversal" => "Reversal Playbook",
        _ => "Scan"
    };

    if (ChartTemplates.Contains(name))
        ChartTemplates.Get(name).Apply(Chart);
}