TL;DR

In diesem Artikel lernst du, wie du einen neuen cBot für die Handelsplattform cTrader erstellst. Wir erklären, worauf du bei der Projektstruktur achten solltest, welche Dateien und Ordner wichtig sind und geben praktische Tipps für einen sauberen, wartbaren Code. Damit legst du das Fundament für erfolgreiche Trading-Bots in C#.

Einführung: Was ist ein cBot und warum ist die Projektstruktur wichtig?

Ein cBot ist ein automatisiertes Handelssystem für die Trading-Plattform cTrader. Mit cBots lassen sich Handelsstrategien in C# programmieren und rund um die Uhr ausführen. Damit ein cBot zuverlässig und effizient arbeitet, ist eine durchdachte Projektstruktur entscheidend. Sie sorgt für Übersicht, erleichtert die Wartung und ermöglicht eine spätere Erweiterung deines Bots[^1].

Voraussetzungen: Was du vor dem Anlegen eines cBots benötigst

Bevor du mit dem Anlegen deines ersten cBots beginnst, solltest du folgende Voraussetzungen erfüllen:

• cTrader installiert: Lade die aktuelle Version von cTrader herunter und installiere sie.
• cTrader Automate API Kenntnisse: Grundkenntnisse in C# und der API von cTrader sind hilfreich.
• Entwicklungsumgebung: Visual Studio (Community Edition reicht) für die komfortable Entwicklung.
• Motivation: Die Bereitschaft, dich mit der Materie auseinanderzusetzen.

Schritt 1: Ein neues cBot-Projekt in cTrader anlegen

Die einfachste Möglichkeit, einen neuen cBot zu erstellen, ist direkt in cTrader:

1. cTrader öffnen
   Starte cTrader und wechsle zum Tab „Automate“.
2. Neues cBot-Projekt erstellen
   Klicke auf „Neues cBot“ oder „New cBot“. Gib deinem Projekt einen aussagekräftigen Namen.
3. Projekt speichern
   Das Projekt wird automatisch im Verzeichnis C:\Users\<Benutzername>\Documents\cTrader\Sources\Robots gespeichert.

Alternativ kannst du den cBot auch in Visual Studio entwickeln und später importieren[^2].

Schritt 2: Die Verzeichnisstruktur eines cBot-Projekts verstehen

Eine saubere Projektstruktur ist das A und O für die Entwicklung wartungsfreundlicher und skalierbarer cBots. Standardmäßig legt cTrader folgende Struktur an:

/MeinNeuercBot/
│
├── MeinNeuercBot.cs
├── Properties/
│ └── AssemblyInfo.cs
└── bin/
└── Debug/
└── MeinNeuercBot.dll

Die wichtigsten Bestandteile:

• MeinNeuercBot.cs: Hier steht der Hauptcode deines Bots. Die Datei enthält die Basisklasse, Methoden wie OnStart(), OnTick(), OnStop().
• Properties/AssemblyInfo.cs: Enthält Metadaten zum Projekt (Version, Copyright).
• bin/Debug/MeinNeuercBot.dll: Das kompilierte Ergebnis, das cTrader ausführt.

Schritt 3: Die wichtigsten Dateien im cBot-Projekt

Die Hauptdatei: <Name>.cs

Hier definierst du die Logik deines Bots. Ein einfaches Grundgerüst sieht so aus:

„`csharp
using cAlgo.API;

namespace MeinNeuercBot
{
[Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
public class MeinNeuercBot : Robot
{
protected override void OnStart()
{
// Initialisierungscode
}

    protected override void OnTick()
    {
        // Logik pro Tick
    }

    protected override void OnStop()
    {
        // Aufräumarbeiten
    }
}

}
„`

Die wichtigsten Methoden

• OnStart(): Wird beim Start des Bots einmalig ausgeführt.
• OnTick(): Wird bei jedem Tick (Preisänderung) aufgerufen.
• OnStop(): Wird beim Stoppen des Bots ausgeführt.

AssemblyInfo.cs

Hier stehen wichtige Informationen über den Bot. Zum Beispiel:

„`csharp
using System.Reflection;

[assembly: AssemblyTitle(„MeinNeuercBot“)]
[assembly: AssemblyDescription(„Ein Beispiel-cBot für cTrader“)]
[assembly: AssemblyVersion(„1.0.0.0“)]
„`

Weitere empfohlene Dateien und Ordner

Gerade bei größeren Projekten empfiehlt sich eine erweiterte Struktur:

/MeinNeuercBot/
│
├── MeinNeuercBot.cs
├── Helpers/
│ └── MathHelper.cs
├── Models/
│ └── TradeModel.cs
├── Strategies/
│ └── BreakoutStrategy.cs
├── Properties/
│ └── AssemblyInfo.cs
└── bin/
└── Debug/
└── MeinNeuercBot.dll

Erläuterung:

• Helpers: Hilfsfunktionen, z.B. für Berechnungen oder Utilities.
• Models: Datenmodelle, z.B. für Trades, Orders.
• Strategies: Einzelne Handelsstrategien, die du modular einbinden kannst.

Schritt 4: Best Practices für die cBot-Projektstruktur

1. Trenne Logik und Hilfsfunktionen

Lagere wiederverwendbare Funktionen in eigene Klassen/Dateien aus (z.B. in den „Helpers“-Ordner). Das erhöht die Lesbarkeit und Wiederverwendbarkeit.

2. Verwende sprechende Namen

Datei- und Klassennamen sollten den Inhalt widerspiegeln. So findest du dich später besser zurecht.

3. Halte die Hauptdatei schlank

Die Hauptdatei sollte nur den Ablauf steuern. Die eigentliche Logik (z.B. Entry/Exit-Regeln) gehört in eigene Klassen.

4. Dokumentiere deinen Code

Kommentiere die wichtigsten Funktionen und Klassen. Das hilft dir und anderen, den Code später nachzuvollziehen.

5. Versionskontrolle nutzen

Verwende Git oder eine andere Versionsverwaltung, um Änderungen nachzuvollziehen und Fehler leichter zu beheben[^3].

Schritt 5: Den cBot kompilieren und testen

Nachdem du deinen Code geschrieben hast, kannst du den cBot direkt in cTrader kompilieren:

• Klicke auf „Kompilieren“ oder drücke F5.
• Prüfe auf Fehlermeldungen im Ausgabefenster.
• Starte den Bot auf einem Demokonto, um die Funktion zu testen.

Für größere Projekte empfiehlt sich die Entwicklung in Visual Studio. Dort hast du mehr Komfort beim Debugging und kannst Unit-Tests schreiben.

Schritt 6: Erweiterte Projektstruktur für professionelle cBots

Bei komplexeren Anforderungen empfiehlt sich eine noch modularere Struktur, wie sie auch in größeren Softwareprojekten üblich ist:

/MeinProfiBot/
│
├── MeinProfiBot.cs
├── Core/
│ ├── TradeManager.cs
│ └── RiskManager.cs
├── Indicators/
│ └── CustomIndicator.cs
├── Strategies/
│ ├── MeanReversionStrategy.cs
│ └── TrendFollowingStrategy.cs
├── Utils/
│ └── Logger.cs
├── Models/
│ └── PositionModel.cs
├── Properties/
│ └── AssemblyInfo.cs
└── Tests/
└── TradeManagerTests.cs

Erklärung der wichtigsten Komponenten:

• Core: Zentrale Steuerungskomponenten wie Trade- oder Risk-Manager.
• Indicators: Eigene oder angepasste Indikatoren.
• Strategies: Verschiedene Handelsstrategien, modular aufgebaut.
• Utils: Hilfsfunktionen wie Logging oder Konvertierungen.
• Tests: Unit-Tests für wichtige Komponenten.

Schritt 7: Wichtige Hinweise zur Wartung und Weiterentwicklung

• Regelmäßig refaktorisieren: Überarbeite deinen Code regelmäßig, um die Struktur sauber zu halten.
• Fehlerprotokolle nutzen: Baue Logging ein, um Fehler schneller zu finden.
• Sicherungen anlegen: Erstelle Backups, bevor du größere Änderungen vornimmst.
• Updates verfolgen: Halte deine cTrader-Version und ggf. genutzte Bibliotheken aktuell.

Fazit: Der Weg zum erfolgreichen cBot beginnt mit einer guten Struktur

Die richtige Projektstruktur ist das Fundament für erfolgreiche und wartbare cBots. Schon beim ersten Bot lohnt es sich, auf Übersichtlichkeit und Modularität zu achten. Mit den hier vorgestellten Best Practices und Beispielen bist du bestens für deine eigenen Trading-Bots vorbereitet.

Weiterführende Quellen

• cTrader Automate API Dokumentation (offiziell)
• cTrader Community Forum
• cTrader cBots und Indikatoren Beispiele
• Microsoft C# Dokumentation
• Git Einführung für Entwickler

[^1]: Was ist ein cBot? – cTrader Hilfe
[^2]: cTrader Automate API – Einstieg
[^3]: Warum Versionskontrolle? – Git SCM