Grafik şablonları

ChartTemplates koleksiyonu ve ChartTemplate nesneleri, manuel konfigürasyonlarla uğraşmak zorunda kalmadan grafik şablonlarını programatik olarak kaydetmenize, yönetmenize ve uygulamanıza olanak tanır. Bu işlevsellik şunlar için kullanışlıdır:

Algoritmaların tutarlı grafik düzenlerini yapılandırmasını ve yönetmesini, sorunsuz şablon geçişini, kurulum yakalamayı ve depolamayı, izlemeyi ve daha fazlasını isteyen trader'lar.
Gelişmiş analiz, izleme, hata ayıklama veya yardımcı göstergelerin ve cBot'ların birçok grafikte dağıtımı için tekrarlanabilir grafik ortamlarına ihtiyaç duyan geliştiriciler.

Temel kavramlar

Tek bir ChartTemplate şunları sunar:

Bir şablonu hedef bir grafiğe uygulamak için template.Apply(Chart).
Göstergeleri eklemek veya kaldırmak, parametrelerine erişmek için template.Indicators.
cBot'ları eklemek veya kaldırmak için template.Robots.
Grafik veya tema renkleriyle çalışmak için template.ColorSettings.
Grafik türü, yakınlaştırma ve pozisyonlar, emirler, ızgara, duyarlılık ve daha fazlası dahil olmak üzere çeşitli geçişlerle çalışmak için template.DisplaySettings.

Yerleşik bir koleksiyon olan ChartTemplates nesnesi şunları sağlar:

Numaralandırma için foreach (var t in ChartTemplates) ....
Sorgulama için ChartTemplates.Get(name), ChartTemplates.Contains(name).
Boş şablonlar oluşturmak için ChartTemplates.Create(name).
Mevcut grafik konfigürasyonunu yakalamak için ChartTemplates.Create(name, Chart).
Şablonları çoğaltmak için ChartTemplates.Duplicate(newName, sourceTemplate).
Şablonları kaldırmak için ChartTemplates.Remove(template).
Varsayılan şablonu uygulamak için ChartTemplates.DefaultTemplate (al veya ayarla).

Ayrıca olayları da sunar:

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

Aşağıdaki tablo standart işlemlerin bir özetini sunar.

İşlem	Örnekler
Şablon yaşam döngüsü	Boş bir şablon oluştur Mevcut grafikten bir şablon oluştur Bir şablonu çoğalt Bir şablonu kaldır
Şablon keşfi	Şablonları listele ve verileri göster Bir şablonun var olup olmadığını kontrol et Bir şablonun eklenmesine veya kaldırılmasına tepki ver
Şablonları uygulama	Bir şablonu bir grafiğe uygula Varsayılan şablonu değiştir
Şablon bileşimi	Bir gösterge ekle veya kaldır Bir göstergenin parametrelerini değiştir Bir cBot ekle veya kaldır
Düzen ve görselleştirme ayarları	Grafik renklerini ayarla Grafik görüntüleme seçeneklerini etkinleştir veya devre dışı bırak Grafik türünü değiştir Yakınlaştırma seviyesini ayarla

Bir grafiğe eklendiğinde ve başlatıldığında, grafik şablonlarıyla çeşitli görevleri gerçekleştirmek için bir menü görüntüleyen bir Grafik Şablonları Yöneticisi cBot'u düşünün.

Varsayılan görünümŞablon seçmeGösterge seçmecBot ekleme

Kod

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

Pratik uygulamalar

Mevcut kurulumu yakala

Bir grafiğin göstergeler, parametreler, renkler ve diğerleri dahil olmak üzere ayarlarını programatik olarak yakalayan ve bunları bir şablon olarak depolayan algoritmalar geliştirin. Bu, algoritmik işlem yapmanın herhangi bir aşamasında çalışan bir kurulumu otomatik olarak korumanıza ve diğer tüm grafiklere uygulamanıza olanak tanır.

Bu C# kodu, bir grafiğin şablonunu yakalayan ve saklayan bir cBot'u göstermektedir:

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

Ayrı çalışma alanları oluşturun

İsteğe bağlı iş akışınızı üç özel grafik düzenine yapılandırın ve aralarında anında geçiş yapın. Yaygın bir isteğe bağlı iş akışı şöyledir:

Tara – minimal grafik, hızlı yükleme, temiz mumlar, dağınıklık yok.
Onayla – trend/volatilite filtreleri gibi göstergeler ve bağlam katmanları.
Uygula – emirleri/pozisyonları/hedefleri ve Hızlı Al Sat düğmelerini göster, dikkat dağıtan her şeyi gizle.

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

Trend işlem yapmayı standartlaştırın

Trendlerle işlem yaparken genellikle üç temel unsura güvenirsiniz: EMA gibi bir trend filtresi, RSI gibi bir momentum veya aşırı alım-aşırı satım ölçüsü ve sabit renkler ile okunabilir katmanlara sahip temiz bir mum grafiği. Bu yapılandırmayı tek bir şablon olarak kaydedebilir ve açtığınız herhangi bir sembole veya zaman dilimine uygulayabilirsiniz.

Standartlaştırılmış bir kurulum, parametre tutarsızlıklarından kaçınmanıza, kurulum hatalarını azaltmanıza ve her grafiğin aynı karar çerçevesini takip etmesini sağlamanıza yardımcı olur.

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

Ortalamaya geri dönüş düzenleri oluşturun

Ortalamaya geri dönüş işlemi yaparken, genellikle daha fazla gösterge bağlamına güvenirsiniz, ancak yine de temiz ve kontrollü bir grafik istersiniz. Analiz sırasında tam olarak neyin görünür kalacağına karar vermek için şablonları kullanın.

Yanlışlıkla girişleri önlemek için Hızlı Al Sat düğmelerini kapatın. Sizi rahatsız ediyorsa duyarlılık panelini gizleyin. Hassas konumlandırma için ızgarayı ve anahtar seviyeleri görünür tutun. Yaklaşımınıza uygun grafik türünü seçin, ister yapı için mumlar ister netlik için çizgi grafik olsun.

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

İzleme şablonları oluşturun

Bir işlemdeyken öncelikleriniz değişir. Açık pozisyonların, bekleyen emirlerin ve hedef seviyelerin net bir şekilde görünürlüğüne, ayrıca istikrarlı ve tutarlı bir grafik görünümüne ihtiyacınız vardır. Yakınlaştırma seviyenizi sabit tutun, fiyat çizgilerinin net bir şekilde görüntülendiğinden emin olun ve yönetim kararlarını doğrudan desteklemeyen göstergeleri kaldırın.

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

Görsel standartları uygulayın

Bir ekip içinde çalışıyorsanız veya tanımlanmış bir iş istasyonu stilini takip ediyorsanız, arka plan rengi, boğa ve ayı mum renkleri, ızgara görünürlüğü ve çizgi stili gibi öğeleri standartlaştırmak için şablonları kullanın. Tek tip bir görsel yapı sağlamak, karışıklığı azaltmak ve iletişimi geliştirmek için tüm grafiklere aynı şablonu uygulayın.

Bu kurulum, ekran görüntüleri paylaştığınızda, strateji incelemeleri yaptığınızda veya kararları devrettiğinizde özellikle önemli hale gelir.

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

Volatilite şablonları ekleyin

Volatilite değiştiğinde, yürütme ve analiz ihtiyaçlarınız değişir. İki ayrı çalışma alanı tanımlamak ve koşullar geliştikçe aralarında geçiş yapmak için şablonlar oluşturun:

Düşük volatilite şablonunda, daha dar bir yakınlaştırma kullanın, katmanları azaltın ve aralık işlemine uygun temiz bir görünüm sağlayın.
Yüksek volatilite şablonunda, daha geniş bir yakınlaştırma kullanın, daha net fiyat çizgileri, ızgarayı etkinleştirin ve daha sıkı yürütme kontrolü için pozisyonları ve emirleri görüntüleyin.

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

Tek tıklamayla bağlamlar oluşturun

Scalping mi yoksa swing trading mi yaptığınıza bağlı olarak genellikle farklı gösterge parametreleri, yakınlaştırma seviyeleri ve görsel tercihler kullanırsınız. Her zaman dilimi değiştirdiğinizde ayarları manuel olarak ayarlamak yerine, her görünüm için özel şablonlar oluşturun.

Örneğin, hızlı yürütme ve daha dar yakınlaştırma için M1-Scalp'i, yapılandırılmış seans işlemi için M15-Intraday'i ve daha geniş bağlam ve daha pürüzsüz katmanlar için H1-Swing'i tanımlayın.

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

Strateji oyun kitapları oluşturun

Birden fazla strateji ailesiyle işlem yapıyorsanız, her oyun kitabı için özel bir şablon tanımlamayı düşünün. Örneğin, şunları yapabilirsiniz:

Yürütme netliği için ızgara etkin, emirler ve pozisyonlar görünür, daha geniş bir yakınlaştırma ve temiz fiyat çizgileri içeren bir kırılma oyun kitabı şablonu kullanın.
EMA ve RSI uygulanmış, normal bir yakınlaştırma seviyesi ve gösterge başlıkları görünür olan bir geri çekilme oyun kitabı şablonu kullanın.
Ek bağlam göstergeleri ve fitilleri ve yapıyı vurgulayan bir mum türü içeren bir geri dönüş oyun kitabı şablonu kullanın.

Her oyun kitabı bir şablon olarak kodlandığında, sinyal türüne göre ortamları değiştirebilir ve yürütmenizi uyguladığınız stratejiyle uyumlu tutabilirsiniz.

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