Aller au contenu

Symboles personnalisés

L'API de symboles personnalisés vous permet de créer et de gérer vos propres symboles dans cTrader. Ces symboles peuvent représenter des actifs synthétiques, des ensembles de données externes, des métriques dérivées ou des instruments complètement hors ligne. Chaque symbole personnalisé peut être défini à l'aide d'un ou deux actifs et prend en charge l'intégration complète avec les périodes, les graphiques, les indicateurs, le backtesting et les mises à jour en temps réel.

Les types et méthodes clés pour les symboles personnalisés incluent :

  • CustomSymbols.Add(name, baseSymbol) ou CustomSymbols.Add(name, baseAsset, quoteAsset) pour créer un nouveau symbole personnalisé.
  • CustomSymbol.BarsNeeded pour fournir des données OHLC pour le symbole à la demande.
  • CustomSymbol.UpdateQuote(bid, ask) pour alimenter le symbole en prix en direct.
  • CustomBars.AppendBars(), UpdateLastBar() et PrependBars() pour gérer dynamiquement les données de barres. Chaque CustomBar stocke Time, Open, High, Low, Close et Volume.

De plus, les développeurs peuvent définir les taux de swap, les commissions, les niveaux de levier, le sentiment, les paramètres de contrats à terme et même les heures de marché ou les jours fériés pour les symboles personnalisés. Une fois créés, les symboles personnalisés sont entièrement interactifs et peuvent être visualisés dans les graphiques ou utilisés de manière programmatique dans les cBots, les indicateurs et les plug-ins.

Conseil

Utilisez les symboles personnalisés pour visualiser des données externes, simuler des spreads ou des corrélations, tester des stratégies sur des ensembles de données propriétaires ou combiner plusieurs actifs en instruments synthétiques.

Les objets API de symboles personnalisés peuvent être utilisés pour effectuer les opérations suivantes :

Fonctionnalité ou opération Exemples
Simulation d'actifs synthétiques Créer un symbole de spread (par exemple UKOIL - USOIL)
Créer des paniers d'actions ou de devises
Visualisation d'ensembles de données hors ligne Charger des données CSV pour les marchés
Tracer les taux d'intérêt historiques ou les indices économiques
Graphiques en direct à partir d'API Alimenter les prix externes en temps réel
Diffuser la juste valeur calculée ou les métriques de risque
Test de stratégie sur des données personnalisées Effectuer un backtesting sur des ensembles de données fondamentales ou alternatives
Simuler des environnements de marché hérités
Génération de cotations synthétiques Dériver des prix personnalisés à partir de symboles existants
Injecter des cotations dans des instruments personnalisés
Modélisation des contraintes de trading Appliquer des sessions personnalisées, des jours fériés, l'expiration de contrats à terme, une structure de swap ou des niveaux de levier
Visualisation des métriques de stratégie Tracer la courbe de fonds propres, le drawdown ou les signaux sous forme de séries de prix pour l'analyse intra-stratégie

Opérations de base

Créer un nouveau symbole personnalisé avec un symbole de base

1
2
3
4
5
var baseSymbol = Symbols.GetSymbol("EURUSD");

var customSymbol = CustomSymbols.Add("MyCustomSymbol1", baseSymbol);
customSymbol.Description = "Synthetic EURUSD Tracker";
customSymbol.UpdateQuote(baseSymbol.Bid, baseSymbol.Ask);

Créer un symbole personnalisé avec des actifs (sans symbole de base)

1
2
3
4
5
var baseAsset = Assets.GetAsset("XAU");
var quoteAsset = Assets.GetAsset("USD");

var customSymbol = CustomSymbols.Add("GoldIndex", baseAsset, quoteAsset);
customSymbol.UpdateQuote(1923.5, 1923.8);

Définir les propriétés statiques de l'instrument

1
2
3
4
5
6
customSymbol.LotSize = 100000;
customSymbol.PipDigits = 2;
customSymbol.TickDigits = 3;
customSymbol.Commission = 3.5;
customSymbol.SwapLong = -0.2;
customSymbol.SwapShort = 0.1;

Attribuer un flux de cotations (en direct ou simulé)

1
2
var tracking = Symbols.GetSymbol("GBPUSD");
tracking.Tick += e => customSymbol.UpdateQuote(e.Symbol.Bid, e.Symbol.Ask);

Gérer la demande de barres pour les données synthétiques

1
2
3
4
5
6
customSymbol.BarsNeeded = args =>
{
    var baseBars = MarketData.GetBars(args.CustomBars.TimeFrame, "EURUSD");
    var newBars = baseBars.Select(b => new CustomBar(b.OpenTime, b.Open, b.High, b.Low, b.Close, b.TickVolume));
    args.CustomBars.AppendBars(newBars);
};

Ajouter une barre en temps réel sur tick

1
2
3
4
5
tracking.Tick += _ =>
{
    var last = MarketData.GetBars(TimeFrame.Minute, tracking.Name).LastBar;
    customSymbol.CustomBars.UpdateLastBar(last.Open, last.High, last.Low, last.Close, last.TickVolume);
};

Ajouter une session de trading personnalisée

1
2
3
4
customSymbol.MarketHours.Sessions.Add(new CustomSymbolTradingSession(
    DayOfWeek.Monday, DayOfWeek.Friday,
    new TimeSpan(8, 0, 0), new TimeSpan(16, 30, 0)
));

Définir les paramètres des contrats à terme

1
2
3
4
5
customSymbol.FuturesSettings = new CustomSymbolFuturesSettings(
    DateTime.UtcNow.AddDays(20),
    DateTime.UtcNow.AddDays(30),
    0.15 // maintenance margin
);

Ajouter des niveaux de levier dynamiques

1
2
customSymbol.DynamicLeverage.Add(new CustomSymbolLeverageTier(100000, 100));
customSymbol.DynamicLeverage.Add(new CustomSymbolLeverageTier(500000, 50));

Créer et ajouter une période personnalisée

1
2
3
4
5
6
7
var customTF = TimeFrameManager.Custom.Add("MyCustomH1");

customTF.BarsNeeded = args =>
{
    var hourly = MarketData.GetBars(TimeFrame.Hour, args.CustomBars.Symbol.Name);
    args.CustomBars.AppendBars(hourly.Select(b => new CustomBar(b.OpenTime, b.Open, b.High, b.Low, b.Close, b.TickVolume)));
};

Importer des données à partir d'un fichier CSV

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
var lines = File.ReadAllLines("data.csv");

var bars = lines.Skip(1).Select(line =>
{
    var parts = line.Split(',');
    return new CustomBar(DateTime.Parse(parts[0]), 
                         double.Parse(parts[1]), double.Parse(parts[2]), 
                         double.Parse(parts[3]), double.Parse(parts[4]), 
                         int.Parse(parts[5]));
});

customSymbol.BarsNeeded = args => args.CustomBars.AppendBars(bars);

Supprimer un symbole personnalisé

1
2
var cs = CustomSymbols.Get("MyCustomSymbol1");
CustomSymbols.Remove(cs);

Exemples d'intégration pratiques

Suivre les données fondamentales au fil du temps

Affichez des indicateurs macroéconomiques tels que l'IPC, le taux de chômage ou le PIB sous forme de barres OHLC synthétiques. Cette approche permet la superposition de stratégies, l'analyse de divergence et le suivi de modèles historiques à l'aide de données économiques structurées.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
var macroSymbol = CustomSymbols.Add("US_MacroIndex", Assets.GetAsset("USD"), Assets.GetAsset("USD"));
macroSymbol.BarsNeeded = args =>
{
    var csvData = LoadCustomCsv("us_macro.csv"); // contains OpenTime, Open, High, Low, Close, Volume
    args.CustomBars.AppendBars(csvData.Select(row => new CustomBar(
        DateTime.Parse(row[0]),
        double.Parse(row[1]),
        double.Parse(row[2]),
        double.Parse(row[3]),
        double.Parse(row[4]),
        int.Parse(row[5])
    )));
};

Créer un panier d'actifs pondéré

Combinez plusieurs actions dans un symbole personnalisé qui reflète un portefeuille pondéré. Cette configuration vous permet de suivre les performances, d'appliquer des indicateurs et de backtester des stratégies sur un indice d'actions synthétique construit à partir de composants sélectionnés.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
var customIndex = CustomSymbols.Add("MyAssetBasket", Assets.GetAsset("USD"), Assets.GetAsset("USD"));
customIndex.BarsNeeded = args =>
{
    var eurusdBars = MarketData.GetBars(TimeFrame.Daily, "EURUSD");
    var gbpusdBars = MarketData.GetBars(TimeFrame.Daily, "GBPUSD");
    var usdjpyBars = MarketData.GetBars(TimeFrame.Daily, "USDJPY");

    var indexBars = Enumerable.Range(0, Math.Min(eurusdBars.Count, Math.Min(gbpusdBars.Count, usdjpyBars.Count)))
        .Select(i =>
        {
            var time = eurusdBars[i].OpenTime;
            var weightedClose = eurusdBars[i].Close * 0.4 + gbpusdBars[i].Close * 0.35 + usdjpyBars[i].Close * 0.25;

            return new CustomBar(time, weightedClose, weightedClose, weightedClose, weightedClose, 0);
        });

    args.CustomBars.AppendBars(indexBars);
};

Suivre les différentiels de prix des matières premières

Envisagez de créer un symbole personnalisé qui représente l'écart de prix entre l'or et l'argent (XAUUSD - XAGUSD). Ce symbole personnalisé peut faciliter les stratégies de trading de spread, la détection de divergence et l'analyse intermarché sur les métaux précieux.

En analysant la différence de mouvements de prix entre l'or et l'argent, les traders peuvent identifier la force relative, les opportunités d'arbitrage potentielles ou couvrir une position contre l'autre.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
var spreadSymbol = CustomSymbols.Add("Gold_Silver_Spread", Assets.GetAsset("USD"), Assets.GetAsset("USD"));
spreadSymbol.BarsNeeded = args =>
{
    var gold = MarketData.GetBars(TimeFrame.Hour, "XAUUSD");
    var silver = MarketData.GetBars(TimeFrame.Hour, "XAGUSD");

    var spread = gold.Zip(silver, (g, s) => new CustomBar(
        g.OpenTime,
        g.Close - s.Close,
        g.Close - s.Close,
        g.Close - s.Close,
        g.Close - s.Close,
        g.TickVolume + s.TickVolume
    ));

    args.CustomBars.AppendBars(spread);
};

Diffuser un symbole de spread FX en direct

Créez un instrument synthétique en temps réel en soustrayant les prix de deux paires de devises.
Ce symbole personnalisé permet de tracer et de trader le spread directement, en prenant en charge les stratégies de retour à la moyenne, le suivi visuel et la couverture basée sur le spread.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
private CustomSymbol _eurGbpSpread;
private Symbol _eurusd, _gbpusd;

protected override void OnStart()
{
    _eurusd = Symbols.GetSymbol("EURUSD");
    _gbpusd = Symbols.GetSymbol("GBPUSD");

    _eurGbpSpread = CustomSymbols.Add("EUR‑GBP Spread",
                                      _eurusd.QuoteAsset,  // both legs already trade in USD
                                      _eurusd.QuoteAsset);

    // propagate tick updates
    _eurusd.Tick  += OnLegTick;
    _gbpusd.Tick  += OnLegTick;
}

private void OnLegTick(SymbolTickEventArgs _)
{
    var mid = _eurusd.Bid - _gbpusd.Bid;        // naïve spread
    _eurGbpSpread.UpdateQuote(mid, mid + 0.00001); // 0.1 pip synthetic spread
}