Chart-Vorlagen

Die Sammlung ChartTemplates und die Objekte ChartTemplate ermöglichen es Ihnen, Chartvorlagen programmgesteuert zu speichern, zu verwalten und anzuwenden, ohne sich mit manuellen Konfigurationen befassen zu müssen. Diese Funktionalität ist nützlich für:

Händler, die möchten, dass Algorithmen konsistente Chartlayouts konfigurieren und handhaben, reibungsloses Vorlagenwechseln, Setup-Erfassung und -Speicherung, Überwachung und mehr.
Entwickler, die wiederholbare Chartumgebungen für erweiterte Analysen, Überwachung, Debugging oder Bereitstellung von Hilfsindikatoren und cBots über viele Charts hinweg benötigen.

Kernkonzepte

Ein einzelnes ChartTemplate bietet:

template.Apply(Chart), um eine Vorlage auf einen Zielchart anzuwenden.
template.Indicators, um Indikatoren hinzuzufügen oder zu entfernen und auf ihre Parameter zuzugreifen.
template.Robots, um cBots hinzuzufügen oder zu entfernen.
template.ColorSettings, um mit Chart- oder Themenfarben zu arbeiten
template.DisplaySettings, um mit Charttyp, Zoom und verschiedenen Umschaltern zu arbeiten, einschließlich Positionen, Orders, Raster, Stimmung und mehr.

Das Objekt ChartTemplates, eine integrierte Sammlung, bietet:

foreach (var t in ChartTemplates) ... für die Aufzählung.
ChartTemplates.Get(name), ChartTemplates.Contains(name) für Abfragen.
ChartTemplates.Create(name) zum Erstellen leerer Vorlagen.
ChartTemplates.Create(name, Chart) zum Erfassen der aktuellen Chartkonfiguration.
ChartTemplates.Duplicate(newName, sourceTemplate) zum Duplizieren von Vorlagen.
ChartTemplates.Remove(template) zum Entfernen von Vorlagen.
ChartTemplates.DefaultTemplate zum Anwenden der Standardvorlage (Abrufen oder Festlegen).

Es bietet auch Ereignisse:

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

Die folgende Tabelle bietet eine Zusammenfassung der Standardoperationen.

Vorgang	Beispiele
Vorlagenlebenszyklus	Eine leere Vorlage erstellen Eine Vorlage aus dem aktuellen Chart erstellen Eine Vorlage duplizieren Eine Vorlage entfernen
Vorlagenerkennung	Vorlagen auflisten und Daten anzeigen Prüfen, ob eine Vorlage existiert Auf das Hinzufügen oder Entfernen einer Vorlage reagieren
Vorlagen anwenden	Eine Vorlage auf einen Chart anwenden Standardvorlage ändern
Vorlagenzusammensetzung	Einen Indikator hinzufügen oder entfernen Die Parameter eines Indikators ändern Einen cBot hinzufügen oder entfernen
Layout- und Visualisierungseinstellungen	Die Chartfarben festlegen Die Chartanzeigeoptionen aktivieren oder deaktivieren Den Charttyp ändern Die Zoomstufe anpassen

Betrachten Sie einen Chart Templates Manager cBot, der, wenn er zu einem Chart hinzugefügt und gestartet wird, ein Menü zur Durchführung verschiedener Aufgaben mit Chartvorlagen anzeigt.

StandardansichtVorlagen auswählenIndikatoren auswählencBots hinzufügen

Code

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

Praktische Anwendungen

Das aktuelle Setup erfassen

Entwickeln Sie Algorithmen, die programmgesteuert die Einstellungen eines Charts erfassen, einschließlich Indikatoren, Parameter, Farben und andere, und sie als Vorlage speichern. Dies ermöglicht es Ihnen, ein funktionierendes Setup während jeder Phase des algorithmischen Handels automatisch zu bewahren und es auf beliebige andere Charts anzuwenden.

Dieser C#-Code demonstriert einen cBot, der die Vorlage eines Charts erfasst und speichert:

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

Unterschiedliche Workspaces erstellen

Strukturieren Sie Ihren diskretionären Workflow in drei dedizierte Chartlayouts und wechseln Sie sofort zwischen ihnen. Ein gängiger diskretionärer Workflow ist:

Scannen – minimaler Chart, schnelles Laden, saubere Candles, keine Unordnung.
Bestätigen – Indikatoren und Kontext-Overlays, wie z. B. Trend-/Volatilitätsfilter.
Ausführen – Orders/Positionen/Ziele und Soforthandel-Buttons anzeigen, alles Ablenkende ausblenden.

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

Trendhandel standardisieren

Beim Handel mit Trends verlassen Sie sich typischerweise auf drei Kernelemente: einen Trendfilter wie einen EMA, eine Momentum- oder Überkauft-Überverkauft-Messung wie RSI und einen sauberen Candlestick-Chart mit stabilen Farben und lesbaren Overlays. Sie können diese Konfiguration als einzelne Vorlage speichern und auf jedes Symbol oder jeden Zeitrahmen anwenden, den Sie öffnen.

Ein standardisiertes Setup hilft Ihnen, Parameterinkonsistenzen zu vermeiden, Setup-Fehler zu reduzieren und sicherzustellen, dass jeder Chart demselben Entscheidungsrahmen folgt.

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

Mean-Reversion-Layouts erstellen

Beim Handel mit Mean Reversion verlassen Sie sich oft auf mehr Indikatorkontext, möchten aber dennoch einen sauberen und kontrollierten Chart. Verwenden Sie Vorlagen, um genau zu bestimmen, was während der Analyse sichtbar bleibt.

Schalten Sie Soforthandel-Buttons aus, um versehentliche Einstiege zu verhindern. Blenden Sie das Sentiment-Panel aus, wenn es Sie ablenkt. Halten Sie das Raster und wichtige Levels für präzise Positionierung sichtbar. Wählen Sie den Charttyp, der zu Ihrem Ansatz passt, ob Candlesticks für Struktur oder ein Linienchart für Klarheit.

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

Monitoring-Vorlagen erstellen

Wenn Sie sich in einer Transaktion befinden, ändern sich Ihre Prioritäten. Sie benötigen klare Sichtbarkeit offener Positionen, ausstehender Orders und Ziellevel sowie eine stabile und konsistente Chartansicht. Halten Sie Ihre Zoomstufe fest, stellen Sie sicher, dass Preislinien klar angezeigt werden, und entfernen Sie Indikatoren, die Managemententscheidungen nicht direkt unterstützen.

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

Visuelle Standards durchsetzen

Wenn Sie in einem Team arbeiten oder einem definierten Workstation-Stil folgen, verwenden Sie Vorlagen, um Elemente wie Hintergrundfarbe, Bull- und Bear-Candle-Farben, Rastersichtbarkeit und Linienstil zu standardisieren. Wenden Sie dieselbe Vorlage auf alle Charts an, um eine einheitliche visuelle Struktur sicherzustellen, Verwirrung zu reduzieren und die Kommunikation zu verbessern.

Dieses Setup wird besonders wichtig, wenn Sie Screenshots teilen, Strategieüberprüfungen durchführen oder Entscheidungen übergeben.

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

Volatilitätsvorlagen hinzufügen

Wenn sich die Volatilität ändert, ändern sich Ihre Ausführungs- und Analyseanforderungen. Erstellen Sie Vorlagen, um zwei unterschiedliche Workspaces zu definieren, und wechseln Sie zwischen ihnen, während sich die Bedingungen entwickeln:

Verwenden Sie in der Vorlage für niedrige Volatilität einen engeren Zoom, reduzieren Sie Overlays und behalten Sie eine saubere Ansicht bei, die für Range-Trading geeignet ist.
Verwenden Sie in der Vorlage für hohe Volatilität einen weiteren Zoom, klarere Preislinien, aktivieren Sie das Raster und zeigen Sie Positionen und Orders für engere Ausführungskontrolle an.

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

One-Click-Kontexte erstellen

Sie verwenden oft unterschiedliche Indikatorparameter, Zoomstufen und visuelle Präferenzen, je nachdem, ob Sie Scalping oder Swing-Trading betreiben. Anstatt die Einstellungen jedes Mal manuell anzupassen, wenn Sie Zeitrahmen wechseln, erstellen Sie dedizierte Vorlagen für jede Ansicht.

Definieren Sie beispielsweise M1-Scalp für schnelle Ausführung und engeren Zoom, M15-Intraday für strukturierten Sitzungshandel und H1-Swing für breiteren Kontext und glattere Overlays.

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

Strategie-Playbooks erstellen

Wenn Sie mehrere Strategiefamilien handeln, sollten Sie in Betracht ziehen, eine dedizierte Vorlage für jedes Playbook zu definieren. Sie können beispielsweise:

Eine Breakout-Playbook-Vorlage mit aktiviertem Raster, sichtbaren Orders und Positionen, einem weiteren Zoom und sauberen Preislinien für Ausführungsklarheit verwenden.
Eine Pullback-Playbook-Vorlage mit angewendetem EMA und RSI, einer normalen Zoomstufe und sichtbaren Indikatortiteln verwenden.
Eine Reversal-Playbook-Vorlage mit zusätzlichen Kontextindikatoren und einem Candle-Typ verwenden, der Dochte und Struktur hervorhebt.

Wenn jedes Playbook als Vorlage codiert ist, können Sie Umgebungen basierend auf dem Signaltyp wechseln und Ihre Ausführung mit der Strategie, die Sie anwenden, in Einklang halten.

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