Vai al contenuto

Come lavorare con l'archiviazione locale

In questo articolo e nel video corrispondente spiegheremo cos'è l'archiviazione locale e come può essere utilizzata nei tuoi algoritmi cTrader. Forniremo anche esempi utili e spiegheremo come funziona l'ambito dell'archiviazione locale.

Perché utilizzare l'archiviazione locale

Ci sono molti casi in cui vuoi che il tuo algoritmo salvi qualcosa nel file system locale o vi acceda. Ad esempio, potresti voler salvare un registro di tutte le operazioni del cBot. Tuttavia, questo di solito richiede che l'algoritmo abbia diritti di accesso elevati (AccessRights.FullAccess), il che è tutt'altro che ideale per gli utenti. Se un algoritmo richiede a un utente di fornire autorizzazioni elevate, è molto meno probabile che l'utente si fidi dell'algoritmo, soprattutto se viene distribuito senza il suo codice sorgente. L'archiviazione locale è un modo conveniente per accedere in modo sicuro al file system locale senza introdurre problemi di sicurezza. L'utilizzo dell'archiviazione locale consente agli sviluppatori di mantenere i diritti di accesso dei loro algoritmi impostati su AccessRights.None.

Salvare stringhe nell'archiviazione locale

Ogni tipo di algoritmo cTrader ha una proprietà LocalStorage che consente di eseguire operazioni di lettura e scrittura. Per dimostrare come funziona l'archiviazione locale, creeremo un nuovo cBot. Nel suo gestore OnStart, useremo il metodo LocalStorage.SetString(string key, string value). Come puoi vedere, accetta due argomenti, ovvero una chiave sotto la quale salvare le informazioni e il valore da salvare.

1
LocalStorage.SetString("Message", Message);

Per recuperare il valore, useremo il metodo GetString(string key) nel gestore OnTick del cBot.

1
Print(LocalStorage.GetString("Message"));

Finché Message non è null, possiamo compilare il cBot e vedere il valore recuperato stampato correttamente nel log.

Salvare oggetti nell'archiviazione locale

Oltre alle stringhe, puoi usare l'archiviazione locale per salvare qualsiasi tipo di oggetto. Dietro le quinte, cTrader serializza e deserializza gli oggetti nell'archiviazione locale, consentendo la condivisione di qualsiasi tipo di dati. Per dimostrarlo, possiamo creare una nuova classe per archiviare le informazioni, salvarle e recuperarle in seguito. Chiameremo questa classe Signal.

1
2
3
4
5
6
class Signal
{
    public TradeType TradeType { get; set; }
    public double SL { get; set; }
    public double TP { get; set; }
}

Nel metodo OnStart(), creeremo una nuova istanza di questa classe e inizializzeremo le sue proprietà.

1
2
3
4
5
var signal = new Signal{
    TradeType = TradeType.Sell,
    SL = 50,
    TP = 50,
};

Useremo il metodo SetObject(string key, Object object) per salvare e recuperare il saldo del conto.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
protected override void OnStart()
{
    var signal = new Signal{
    TradeType = TradeType.Sell,
    SL = 50,
    TP = 50,
    };        

    LocalStorage.SetString("Message",Message);
    LocalStorage.SetObject("Signal 1", signal);
}

protected override void OnTick()
{
Print(LocalStorage.GetString("Message")); 

var signal = LocalStorage.GetObject<Signal>("Signal 1"); 
Print(signal.TradeType);
Print(signal.SL);
Print(signal.TP);
}

Se compiliamo il nostro cBot e lo avviamo, dovremmo vedere i valori corretti stampati nel log.

Ambiti dell'archiviazione locale

Quando usi l'archiviazione locale puoi anche definire l'ambito in cui i valori salvati sono esposti per il recupero futuro. Sono disponibili tre diversi ambiti:

  • Ambito istanza - i valori salvati sono disponibili solo per un'istanza specifica.
  • Ambito tipo - i valori salvati sono disponibili per tutte le istanze di un algoritmo specifico.
  • Ambito dispositivo - i valori salvati sono disponibili per tutti gli algoritmi indipendentemente dal loro tipo.

Ecco come potrebbe apparire l'uso dell'ambito istanza.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
[Parameter()]
public bool IsWriter { get; set; }


protected override void OnStart()
{   
    if(IsWriter)
    { 
        LocalStorage.SetString("Message",Message, LocalStorageScope.Instance);
    }
}

protected override void OnTick()
{        
    if(!IsWriter)
    {
        if(LocalStorage.GetString("Message") != string.Empty)
            Print(LocalStorage.GetString("Message"));
    }
}

Nota che abbiamo specificato esplicitamente l'ambito nel metodo SetString().

Possiamo aggiungere diverse istanze di questo cBot e configurarle in modo che una scriva nell'archiviazione locale mentre un'altra recuperi le informazioni. In questo caso, la lettura delle informazioni dovrebbe essere impossibile. Tuttavia, se viene configurata una sola istanza per eseguire sia le operazioni di scrittura che di lettura, il cBot dovrebbe funzionare come previsto.

Ecco un esempio di utilizzo dell'ambito tipo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
protected override void OnStart()
{   
    if(IsWriter)
    {             
        LocalStorage.SetString("Message",Message, LocalStorageScope.Type);
    }
}

protected override void OnTick()
{        
    if(!IsWriter)
    {
        if(LocalStorage.GetString("Message", LocalStorageScope.Type) != string.Empty)
            Print(LocalStorage.GetString("Message"));
    }
}

Se creiamo due istanze di questo bot e le configuriamo in modo che un'istanza scriva nell'archiviazione locale e un'altra legga il valore salvato, tutto dovrebbe funzionare senza generare errori.

Ultimo ma non meno importante, l'ambito dispositivo consente lo scambio di informazioni tra diversi algoritmi. Ecco un esempio di utilizzo di questo tipo di ambito.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
protected override void OnStart()
{   
    if(IsWriter)
    {             
        LocalStorage.SetString("Message",Message, LocalStorageScope.Device);
    }
}

protected override void OnTick()
{        
    if(!IsWriter)
    {
        if(LocalStorage.GetString("Message", LocalStorageScope.Device) != string.Empty)
            Print(LocalStorage.GetString("Message"));
    }
}

Possiamo compilare diversi cBot che usano tutti lo stesso codice. Se li configuriamo correttamente, un cBot può salvare informazioni nell'archiviazione locale mentre un altro le recupera. Finché l'ambito è uguale a LocalStorageScope.Device, il nostro sistema dovrebbe funzionare come previsto.

Usare i metodi Flush() e Reload()

Se vuoi condividere informazioni tra diverse istanze di cTrader, chiama i metodi Flush() e Reload().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
protected override void OnStart()
{   
    if(IsWriter)
    {             
        LocalStorage.SetString("Message",Message, LocalStorageScope.Device);
        LocalStorage.Flush(LocalStorageScope.Device);
    }
}

protected override void OnTick()
{        
    if(!IsWriter)
    {
        LocalStorage.Reload(LocalStorageScope.Device);
        if(LocalStorage.GetString("Message", LocalStorageScope.Device) != string.Empty)
            Print(LocalStorage.GetString("Message"));
    }
}

Se compiliamo diversi cBot con questo codice e conduciamo un esperimento per condividere informazioni tra diverse istanze di cTrader, vedremo che i nostri valori salvati vengono conservati come previsto.