Zum Inhalt

Benutzerdefinierte Währungspaare

Die API für benutzerdefinierte Währungspaare ermöglicht es Ihnen, Ihre eigenen Währungspaare in cTrader zu erstellen und zu verwalten. Diese Währungspaare können synthetische Vermögenswerte, externe Datensätze, abgeleitete Metriken oder vollständig Offline-Instrumente darstellen. Jedes benutzerdefinierte Währungspaar kann mit einem oder zwei Vermögenswerten definiert werden und unterstützt die vollständige Integration mit Zeitrahmen, Charting, Indikatoren, Backtesting und Echtzeit-Updates.

Zu den wichtigsten Typen und Methoden für benutzerdefinierte Währungspaare gehören:

  • CustomSymbols.Add(name, baseSymbol) oder CustomSymbols.Add(name, baseAsset, quoteAsset) zum Erstellen eines neuen benutzerdefinierten Währungspaars.
  • CustomSymbol.BarsNeeded zur bedarfsgerechten Bereitstellung von OHLC-Daten für das Währungspaar.
  • CustomSymbol.UpdateQuote(bid, ask) zur Übermittlung von Live-Kursen an das Währungspaar.
  • CustomBars.AppendBars(), UpdateLastBar() und PrependBars() zur dynamischen Verwaltung von Balkendaten. Jeder CustomBar speichert Time, Open, High, Low, Close und Volume.

Darüber hinaus können Entwickler Swap-Sätze, Provisionen, Hebelstufen, Stimmung, Futures-Einstellungen und sogar Marktzeiten oder Feiertage für benutzerdefinierte Währungspaare definieren. Einmal erstellt, sind benutzerdefinierte Währungspaare vollständig interaktiv und können in Charts angezeigt oder programmatisch in cBots, Indikatoren und Plugins verwendet werden.

Tipp

Verwenden Sie benutzerdefinierte Währungspaare, um externe Daten zu visualisieren, Spreads oder Korrelationen zu simulieren, Strategien auf proprietären Datensätzen zu testen oder mehrere Vermögenswerte zu synthetischen Instrumenten zu kombinieren.

API-Objekte für benutzerdefinierte Währungspaare können für Folgendes verwendet werden:

Funktion oder Vorgang Beispiele
Simulieren synthetischer Vermögenswerte Erstellen eines Spread-Währungspaars (z. B. UKOIL - USOIL)
Erstellen von Aktien- oder Währungskörben
Visualisieren von Offline-Datensätzen Laden von CSV-Daten für Märkte
Darstellen historischer Zinssätze oder Wirtschaftsindizes
Live-Charting von APIs Übermitteln externer Echtzeitkurse
Streamen berechneter Fair Values oder Risikometriken
Strategietests auf benutzerdefinierten Daten Backtesting auf fundamentalen oder alternativen Datensätzen
Simulieren historischer Marktumgebungen
Generieren synthetischer Kurse Ableiten benutzerdefinierter Kurse aus bestehenden Währungspaaren
Einspeisen von Kursen in benutzerdefinierte Instrumente
Modellierung von Handelsbeschränkungen Anwenden benutzerdefinierter Handelszeiten, Feiertage, Futures-Ablauf, Swap-Struktur oder Hebelstufen
Visualisierung von Strategiemetriken Darstellen von Eigenkapitalkurve, Drawdown oder Signalen als Kursreihen für strategieinterne Analysen

Grundlegende Vorgänge

Erstellen eines neuen benutzerdefinierten Währungspaars mit Basiswährungspaar

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

Erstellen eines benutzerdefinierten Währungspaars mit Vermögenswerten (ohne Basiswährungspaar)

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

Definieren der statischen Instrumenteneigenschaften

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;

Zuweisen eines Kurs-Feeds (live oder simuliert)

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

Bearbeiten der Balkenanforderung für synthetische Daten

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

Anhängen eines Echtzeit-Balkens bei 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);
};

Hinzufügen einer benutzerdefinierten Handelszeit

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

Definieren von Futures-Einstellungen

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

Hinzufügen dynamischer Hebelstufen

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

Erstellen und Hinzufügen eines benutzerdefinierten Zeitraums

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

Importieren von Daten aus 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);

Entfernen eines benutzerdefinierten Währungspaars

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

Praktische Integrationsbeispiele

Verfolgen Sie fundamentale Daten im Zeitverlauf

Zeigen Sie makroökonomische Indikatoren wie CPI, Arbeitslosenquote oder BIP als synthetische OHLC-Balken an. Dieser Ansatz ermöglicht Strategie-Overlay, Divergenzanalyse und historische Musterverfolgung unter Verwendung strukturierter Wirtschaftsdaten.

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

Erstellen Sie einen gewichteten Vermögenskorb

Kombinieren Sie mehrere Aktien zu einem benutzerdefinierten Währungspaar, das ein gewichtetes Portfolio widerspiegelt. Diese Einrichtung ermöglicht es Ihnen, die Performance zu verfolgen, Indikatoren anzuwenden und Strategien auf einem synthetischen Aktienindex zu testen, der aus ausgewählten Komponenten erstellt wurde.

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

Verfolgen Sie Rohstoffpreisdifferenzen

Erwägen Sie die Erstellung eines benutzerdefinierten Währungspaars, das den Kursspread zwischen Gold und Silber (XAUUSD - XAGUSD) darstellt. Dieses benutzerdefinierte Währungspaar kann bei Spread-Trading-Strategien, Divergenzerkennung und Intermarket-Analysen bei Edelmetallen hilfreich sein.

Durch die Analyse der Differenz bei Preisbewegungen zwischen Gold und Silber können Händler relative Stärke, potenzielle Arbitragemöglichkeiten identifizieren oder eine Position gegen die andere absichern.

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

Streamen eines Live-FX-Spread-Währungspaars

Erstellen Sie ein synthetisches Echtzeit-Instrument, indem Sie die Preise von zwei Forex-Paaren subtrahieren.
Dieses benutzerdefinierte Währungspaar ermöglicht das Charting und den Handel des Spreads direkt und unterstützt Mean-Reversion-Strategien, visuelle Nachverfolgung und Spread-basiertes Hedging.

 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
}