Accesso alla rete

Questa guida definisce come puoi creare algoritmi in grado di accedere a Internet. Di seguito è riportato un riepilogo di un minuto di questa funzionalità API.

HTTP

La nuova interfaccia Http contiene diversi metodi che, una volta implementati, dovrebbero consentire ai cBot e ad altri tipi di algoritmi di accedere a Internet. Per un'illustrazione, vedi quanto segue:

• HttpResponse Http.Get(string uri). Esegue una richiesta GET all'URI specificato nella stringa passata uri e restituisce un oggetto HttpsResponse contenente i risultati di questa richiesta.

La classe HttpsRequest consente di eseguire richieste più complesse, incluse le richieste POST. Per eseguire queste richieste, imposta la proprietà HttpsRequest.Method su uno dei valori dell'enum HttpMethod come HttpMethod.Put o HttpMethod.Patch.

A sua volta, la proprietà HttpsRequest.Uri contiene l'URI a cui viene inviata una richiesta, mentre la proprietà HttpsRequest.Body può essere utilizzata per impostare il corpo della richiesta. Vedi di seguito un esempio di come puoi utilizzare un oggetto HttpsRequest.

• HttpResponse Http.Send(HttpRequest request). Esegue una richiesta all'URI specificato come valore della proprietà request.Uri dell'oggetto HttpsRequest passato a questo metodo. Successivamente, restituisce un oggetto HttpsResponse contenente i risultati di questa richiesta. Il tipo di richiesta è impostato come valore della proprietà equest.Method.

Crea cBot di esempio

Esegui una richiesta GET

Creeremo un semplice cBot che esegue le seguenti azioni:

• Invia una richiesta GET e accede a un file JSON tramite l'API su https://forexApiExample.com/v1/exchangerate (nota che questa API è completamente fittizia).
• Se la risposta GET ha successo, il cBot deserializza il corpo della risposta in un oggetto di una classe personalizzata SymbolPrice (abbiamo creato questa classe a scopo dimostrativo).
• Piazza un ordine limite di vendita per un simbolo a un prezzo leggermente superiore al prezzo specificato nell'API.

Nota che il cBot è completamente inventato. Sebbene il codice venga compilato, non eseguirà alcuna azione significativa.

Ecco il codice del nostro cBot di esempio:

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

Se questo cBot dovesse accedere a un'API reale, lo avrebbe fatto con successo.

Esegui una richiesta POST

Possiamo anche creare un cBot più avanzato che raggiunge i seguenti obiettivi:

• Invia una richiesta POST alla stessa API fittizia su https://anotherForexApiExample.com/commodities/v1/getaccesstoken. Questo viene fatto per ottenere un token di accesso per questa API.
• Memorizza il token dal corpo della risposta nella variabile token.
• Esegue una richiesta GET alla stessa API con il valore della variabile token passato come parametro di query nell'URI (https://anotherForexApiExample.com/commodities/v1/getprices).
• Utilizzando la serializzazione JSON (discussa sopra), piazza un ordine stop di acquisto a un prezzo leggermente inferiore al prezzo ricevuto dall'API.

Ancora una volta, nota che questo cBot non eseguirà alcuna azione significativa quando compilato. Esiste solo a scopo di esempio.

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

Client WebSocket

L'API Algo consente a chiunque di utilizzare vari servizi e risorse web utilizzando una connessione websocket. Rispetto al protocollo HTTP che viene utilizzato nella funzionalità di accesso alla rete, il protocollo WebSocket è più veloce e consente di ricevere dati in tempo reale.

Utilizza il client WebSocket

Utilizzare il client WebSocket è semplice:

1. Scegli un servizio che espone un endpoint per una connessione websocket
2. Inizializza un oggetto della classe WebSocketClientOptions e specifica i suoi parametri per configurare il tuo client.
3. Inizializza un oggetto della classe WebSocketClient e passa le opzioni create in precedenza al costruttore.
4. Utilizza il metodo Connect() per connetterti alla risorsa scelta e invia dati tramite il metodo Send().
5. Utilizza i gestori di eventi TextReceived() e BinaryReceived() per impostare cosa dovrebbe fare il tuo algoritmo quando il client WebSocket riceve nuovi dati.

Di seguito, creeremo un semplice cBot che si connette a un servizio di notizie economiche immaginario tramite websocket. Quando viene pubblicata una nuova notizia sul simbolo a cui il cBot è attualmente collegato, l'algoritmo mostrerà una finestra di messaggio contenente il testo della notizia.

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

Come puoi vedere, il nostro codice è piuttosto compatto poiché possiamo gestire l'evento WebSocketClient.TextReceived per mostrare la finestra di messaggio. Nota che il nostro cBot non richiede attivamente informazioni dai servizi. Invece, reagisce dinamicamente alle nuove informazioni che gli vengono fornite.

Vantaggi di WebSocket

Poiché websocket consente di reagire a nuovi dati dal web in tempo reale, è perfetto per l'integrazione con servizi di terze parti che possono notificare autonomamente ai tuoi algoritmi qualcosa. Ecco alcuni esempi di risorse web con cui puoi utilizzare il client WebSocket.

• Un calendario di notizie economiche. Quando viene pubblicata una nuova notizia, il tuo algoritmo può mostrare una finestra di messaggio con le informazioni chiave.
• Un servizio di intelligenza artificiale generativa. Quando un servizio di IA inizia a fornire una risposta a un prompt, puoi mostrare il risultato parola per parola anziché dover attendere la risposta completa.
• Un flusso di prezzi per tutti i simboli correlati a quello a cui è collegato un algoritmo. Quando i prezzi vengono aggiornati, vengono mostrati immediatamente e con precisione agli utenti dell'algoritmo.
• Un social network incentrato sul trading. Quando vengono pubblicati nuovi messaggi su un particolare simbolo, un algoritmo può mostrarne i contenuti agli utenti.

In generale, le connessioni websocket offrono i seguenti vantaggi rispetto all'HTTPS normale:

• Le connessioni WebSocket sono più efficienti. Qualsiasi richiesta HTTP deve contenere dati aggiuntivi come le intestazioni. Con websocket, la connessione viene stabilita una sola volta, dopodiché non è necessario inviare dati ridondanti.
• Le connessioni WebSocket offrono una migliore concorrenza. Non è necessario interrompere le operazioni dell'algoritmo fino a quando non si attende una risposta dopo aver inviato una richiesta HTTP. Con websocket, puoi inviare e ricevere dati in qualsiasi momento e gestirli in modo asincrono.

Il client WebSocket consente a tutti i tipi di algoritmi di interagire dinamicamente con le risorse web; questa interazione è più veloce ed efficiente rispetto all'utilizzo di HTTP. Utilizza il client WebSocket per creare potenti algoritmi integrati con servizi di terze parti.

Accesso alla rete e la proprietà AccessRights

In breve, l'enum AccessRights definisce se gli algoritmi hanno accesso a dati esterni a cTrader come il file system della tua macchina locale. Puoi saperne di più in questo tutorial.

Impostare AccessRights su AccessRights.FullAccess consente agli algoritmi di eseguire operazioni avanzate (come l'acquisizione di informazioni dal registro di Windows). Gli utenti finali, tuttavia, potrebbero trovare rischioso concedere ai cBot o agli indicatori l'accesso completo in quanto potrebbe portare a una violazione dei dati.

Di conseguenza, AccessRights.None è solitamente l'opzione più sensata se desideri condividere i tuoi prodotti algoritmici con altri. Tuttavia, anche se scegli questa opzione, i tuoi prodotti cTrader sono liberi di accedere al web. L'aggiunta della funzionalità di accesso alla rete all'API di cTrader Algo significa che i cBot non richiedono più che la proprietà AccessRights sia impostata su AccessRights.FullAccess per funzionare con risorse su Internet.

Questo amplia notevolmente le opportunità che gli sviluppatori di algoritmi hanno quando codificano prodotti cTrader che intendono distribuire ad altri trader.

Riepilogo

In conclusione, l'accesso alla rete è una funzionalità potente che consente di espandere notevolmente il numero di operazioni che i tuoi algoritmi possono eseguire senza introdurre rischi aggiuntivi.