Netzwerkzugriff

Dieser Leitfaden definiert, wie Sie Algorithmen erstellen können, die auf das Internet zugreifen können. Nachfolgend finden Sie eine einminütige Zusammenfassung dieser API-Funktion.

HTTP

Die neue Schnittstelle Http enthält mehrere Methoden, die bei Implementierung cBots und anderen Arten von Algorithmen den Zugriff auf das Internet ermöglichen sollten. Ein Beispiel finden Sie im Folgenden:

• HttpResponse Http.Get(string uri). Führt eine GET-Anfrage an den URI aus, der in der übergebenen Zeichenfolge uri angegeben ist, und gibt ein HttpsResponse-Objekt zurück, das die Ergebnisse dieser Anfrage enthält.

Die Klasse HttpsRequest ermöglicht die Durchführung komplexerer Anfragen, einschließlich POST-Anfragen. Um diese Anfragen durchzuführen, setzen Sie die Eigenschaft HttpsRequest.Method auf einen der Werte des enum HttpMethod, z. B. HttpMethod.Put oder HttpMethod.Patch.

Die Eigenschaft HttpsRequest.Uri enthält wiederum den URI, an den eine Anfrage gesendet wird, während die Eigenschaft HttpsRequest.Body zum Festlegen des Anfragetexts verwendet werden kann. Im Folgenden finden Sie ein Beispiel für die Verwendung eines HttpsRequest-Objekts.

• HttpResponse Http.Send(HttpRequest request). Führt eine Anfrage an den URI aus, der als Wert der Eigenschaft request.Uri des HttpsRequest-Objekts angegeben ist, das an diese Methode übergeben wird. Gibt anschließend ein HttpsResponse-Objekt zurück, das die Ergebnisse dieser Anfrage enthält. Der Anforderungstyp wird als Wert der Eigenschaft equest.Method festgelegt.

Beispiel-cBots erstellen

Eine GET-Anfrage durchführen

Wir erstellen einen einfachen cBot, der die folgenden Aktionen ausführt:

• Sendet eine GET-Anfrage und greift über die API unter https://forexApiExample.com/v1/exchangerate auf eine JSON-Datei zu (beachten Sie, dass diese API völlig fiktiv ist).
• Wenn die GET-Antwort erfolgreich ist, deserialisiert der cBot den Antworttext in ein Objekt einer benutzerdefinierten Klasse SymbolPrice (wir haben diese Klasse zu Demonstrationszwecken erstellt).
• Übermittelt eine Verkauf-Limit-Order für ein Symbol zu einem Kurs, der etwas höher ist als der in der API angegebene Kurs.

Beachten Sie, dass der cBot völlig fiktiv ist. Der Code lässt sich zwar erstellen, führt aber keine sinnvollen Aktionen aus.

Hier ist der Code unseres Beispiel-cBots:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class NetworkAccessTest : Robot
    {

        protected override void OnStart()
        {

            var responseToGet = Http.Get("https://forexApiExample.com/v1/exchangerate");

            if (responseToGet.IsSuccessful)
            {
                var tradedSymbol = JsonSerializer.Deserialize<SymbolPrice>(responseToGet.Body);
                var result = PlaceLimitOrder(TradeType.Sell, tradedSymbol.SymbolName, 10000, tradedSymbol.ConversionRate + 0.15);

            }
        }
    }

    public class SymbolPrice
    {
        public string SymbolName { get; set; }
        public double ConversionRate { get; set; }
    }
}

Wenn dieser cBot auf eine echte API zugreifen würde, hätte er dies erfolgreich getan.

Eine POST-Anfrage durchführen

Wir können auch einen fortgeschritteneren cBot erstellen, der die folgenden Ziele erreicht:

• Sendet eine POST-Anfrage an dieselbe fiktive API unter https://anotherForexApiExample.com/commodities/v1/getaccesstoken. Dies geschieht, um ein Zugriffstoken für diese API zu erhalten.
• Speichert das Token aus dem Antworttext in der Variablen token.
• Führt eine GET-Anfrage an dieselbe API aus, wobei der Wert der Variablen token als Abfrageparameter im URI übergeben wird (https://anotherForexApiExample.com/commodities/v1/getprices).
• Übermittelt unter Verwendung der JSON-Serialisierung (siehe oben) eine Kauf-Stop-Order zu einem Kurs, der etwas niedriger ist als der von der API empfangene Kurs.

Beachten Sie noch einmal, dass dieser cBot beim Kompilieren keine sinnvollen Aktionen ausführt. Er dient nur zu Beispielzwecken.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class NetworkAccessTestTwo : Robot
    {

        protected override void OnStart()
        {
            var uriForAccessToken = new Uri("https://anotherForexApiExample.com/commodities/v1/getaccesstoken");

            var postRequest = new HttpRequest(uriForAccessToken);

            postRequest.Method = HttpMethod.Post;

            var responseToPost = Http.Send(postRequest);

            var token = responseToPost.Body;

            var response = Http.Get($"https://anotherForexApiExample.com/commodities/v1/getprices?token={token}");

            if (response.IsSuccessful)
            {
                var tradedSymbol = JsonSerializer.Deserialize<SymbolPrice>(response.Body);

                var result = PlaceStopOrder(TradeType.Buy, tradedSymbol.SymbolName, 10000, tradedSymbol.ConversionRate - 0.15);

            }
        }
    }

    public class SymbolPrice
    {
        public string SymbolName { get; set; }
        public double ConversionRate { get; set; }
    }
}

WebSocket-Client

Die Algo-API ermöglicht es jedem, verschiedene Webdienste und -ressourcen über eine WebSocket-Verbindung zu nutzen. Im Vergleich zum HTTP-Protokoll, das in der Netzwerkzugriffsfunktion verwendet wird, ist das WebSocket-Protokoll schneller und ermöglicht den Empfang von Daten in Echtzeit.

Den WebSocket-Client verwenden

Die Verwendung des WebSocket-Clients ist einfach:

1. Wählen Sie einen Dienst aus, der einen Endpunkt für eine WebSocket-Verbindung bereitstellt
2. Initialisieren Sie ein Objekt der Klasse WebSocketClientOptions und geben Sie dessen Parameter an, um Ihren Client zu konfigurieren.
3. Initialisieren Sie ein Objekt der Klasse WebSocketClient und übergeben Sie die zuvor erstellten Optionen an den Konstruktor.
4. Verwenden Sie die Methode Connect(), um eine Verbindung zu Ihrer gewählten Ressource herzustellen, und senden Sie Daten über die Methode Send().
5. Verwenden Sie die Ereignishandler TextReceived() und BinaryReceived(), um festzulegen, was Ihr Algo tun soll, wenn der WebSocket-Client neue Daten empfängt.

Im Folgenden erstellen wir einen einfachen cBot, der über WebSocket eine Verbindung zu einem imaginären Wirtschaftsnachrichtendienst herstellt. Wenn eine neue Nachricht über das Symbol veröffentlicht wird, an das der cBot derzeit angehängt ist, zeigt der Algo ein Meldungsfeld mit dem Nachrichtentext an.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class ExampleWebSocketBot : Robot
    {

        private static WebSocketClientOptions _webSocketClientOptions = new WebSocketClientOptions 
        {
            KeepAliveInterval = new TimeSpan(0, 1, 30),
            UseDefaultCredentials = true,
        };
        private WebSocketClient _webSocketClient = new WebSocketClient(_webSocketClientOptions);
        private readonly Uri _targetUri = new Uri("ws://amazingnews.com:8000");

        protected override void OnStart()
        {
            _webSocketClient.Connect(_targetUri);
            _webSocketClient.Send("Hello");
            _webSocketClient.TextReceived += NewsReceived;
        }

        protected override void OnStop()
        {
            _webSocketClient.Close(WebSocketClientCloseStatus.NormalClosure);
        }

        private void NewsReceived(WebSocketClientTextReceivedEventArgs args) 
        {
            if (args.Text.Contains(SymbolName)) 
            {
                MessageBox.Show(args.Text, "News!", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK);
            }
        }
    }
}

Wie Sie sehen können, ist unser Code ziemlich kompakt, da wir das Ereignis WebSocketClient.TextReceived behandeln können, um das Meldungsfeld anzuzeigen. Beachten Sie, dass unser cBot nicht aktiv Informationen vom Dienst anfordert. Stattdessen reagiert er dynamisch auf neue Informationen, die ihm bereitgestellt werden.

Vorteile von WebSocket

Da WebSocket das Reagieren auf neue Daten aus dem Web in Echtzeit ermöglicht, eignet es sich perfekt für die Integration mit Drittanbieterdiensten, die Ihre Algos autonom über etwas benachrichtigen können. Hier sind einige Beispiele für Webressourcen, mit denen Sie den WebSocket-Client verwenden können.

• Ein Wirtschaftsnachrichtenkalender. Wenn eine neue Nachricht veröffentlicht wird, kann Ihr Algo ein Meldungsfeld mit wichtigen Informationen anzeigen.
• Ein generativer KI-Dienst. Wenn ein KI-Dienst beginnt, eine Antwort auf eine Eingabeaufforderung zu liefern, können Sie das Ergebnis Wort für Wort anzeigen, anstatt auf die vollständige Antwort warten zu müssen.
• Ein Stream von Kursen für alle Symbole, die mit dem Symbol korrelieren, an das ein Algo angehängt ist. Wenn Kurse aktualisiert werden, werden sie sofort und genau den Algo-Benutzern angezeigt.
• Ein auf den Handel ausgerichtetes soziales Netzwerk. Wenn neue Nachrichten über ein bestimmtes Symbol veröffentlicht werden, kann ein Algo deren Inhalt den Benutzern anzeigen.

Im Allgemeinen bieten WebSocket-Verbindungen die folgenden Vorteile im Vergleich zu regulärem HTTPS:

• WebSocket-Verbindungen sind effizienter. Jede HTTP-Anfrage muss zusätzliche Daten wie Header enthalten. Bei WebSocket wird Ihre Verbindung nur einmal hergestellt, danach müssen keine redundanten Daten mehr gesendet werden.
• WebSocket-Verbindungen bieten verbesserte Parallelität. Es ist nicht erforderlich, Algo-Vorgänge anzuhalten, bis Sie nach dem Senden einer HTTP-Anfrage auf eine Antwort warten. Mit WebSocket können Sie jederzeit Daten senden und empfangen und diese asynchron verarbeiten.

Der WebSocket-Client ermöglicht es allen Arten von Algos, dynamisch mit Webressourcen zu interagieren; diese Interaktion ist schneller und effizienter im Vergleich zur Verwendung von HTTP. Verwenden Sie den WebSocket-Client, um leistungsstarke Algos zu erstellen, die in Dienste von Drittanbietern integriert sind.

Netzwerkzugriff und die AccessRights-Eigenschaft

Kurz gesagt definiert das AccessRights enum, ob Algorithmen Zugriff auf Daten haben, die sich außerhalb von cTrader befinden, wie z. B. das Dateisystem Ihres lokalen Rechners. Weitere Informationen finden Sie in diesem Tutorial.

Wenn Sie AccessRights auf AccessRights.FullAccess setzen, können Algos erweiterte Operationen durchführen (z. B. Informationen aus der Windows-Registrierung abrufen). Die Endbenutzer könnten es jedoch als riskant empfinden, cBots oder Indikatoren vollen Zugriff zu gewähren, da dies zu einer Datenschutzverletzung führen kann.

Daher ist AccessRights.None in der Regel die sinnvollste Option, wenn Sie Ihre Algo-Produkte mit anderen teilen möchten. Selbst wenn Sie sich für diese Option entscheiden, können Ihre cTrader-Produkte jedoch frei auf das Web zugreifen. Die Hinzufügung der Netzwerkzugriffsfunktion zur cTrader Algo API bedeutet, dass cBots die AccessRights-Eigenschaft nicht mehr auf AccessRights.FullAccess setzen müssen, um mit Ressourcen im Internet zu arbeiten.

Dies erweitert die Möglichkeiten, die Algo-Entwickler beim Programmieren von cTrader-Produkten haben, die sie an andere Händler verteilen möchten, erheblich.

Zusammenfassung

Zusammenfassend lässt sich sagen, dass der Netzwerkzugriff eine leistungsstarke Funktion ist, die es ermöglicht, die Anzahl der Operationen, die Ihre Algorithmen ausführen können, erheblich zu erweitern, ohne zusätzliche Risiken einzuführen.