Aller au contenu

Comment utiliser le stockage local

Dans cet article et sa vidéo correspondante, nous expliquerons ce qu'est le stockage local et comment il peut être utilisé dans vos algorithmes cTrader. Nous fournirons également des exemples utiles et expliquerons le fonctionnement de la portée du stockage local.

Pourquoi utiliser le stockage local

Il existe de nombreux cas où vous souhaitez que votre algorithme enregistre quelque chose dans le système de fichiers local ou y accède. Par exemple, vous pouvez vouloir enregistrer un journal de toutes les opérations du cBot. Cependant, cela nécessite généralement que l'algorithme dispose de droits d'accès élevés (AccessRights.FullAccess), ce qui est loin d'être idéal pour les utilisateurs. Si un algorithme demande à un utilisateur de fournir des autorisations élevées, l'utilisateur est beaucoup moins susceptible de faire confiance à l'algorithme, surtout s'il est distribué sans son code source. Le stockage local est un moyen pratique d'accéder en toute sécurité au système de fichiers local sans introduire de problèmes de sécurité. L'utilisation du stockage local permet aux développeurs de maintenir les droits d'accès de leurs algorithmes définis sur AccessRights.None.

Enregistrer des chaînes dans le stockage local

Chaque type d'algorithme cTrader possède une propriété LocalStorage qui permet d'exécuter des opérations de lecture et d'écriture. Pour démontrer le fonctionnement du stockage local, nous allons créer un nouveau cBot. Dans son gestionnaire OnStart, nous utiliserons la méthode LocalStorage.SetString(string key, string value). Comme vous pouvez le voir, elle prend deux arguments, à savoir une clé sous laquelle les informations doivent être enregistrées et la valeur à enregistrer.

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

Pour récupérer la valeur, nous utiliserons la méthode GetString(string key) dans le gestionnaire OnTick du cBot.

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

Tant que Message n'est pas nul, nous pouvons construire le cBot et voir la valeur récupérée correctement affichée dans le journal.

Enregistrer des objets dans le stockage local

Au-delà des chaînes, vous pouvez utiliser le stockage local pour enregistrer tout type d'objet. En coulisses, cTrader sérialise et désérialise les objets dans le stockage local, ce qui permet de partager tout type de données. Pour démontrer cela, nous pouvons créer une nouvelle classe pour stocker des informations, l'enregistrer et la récupérer ultérieurement. Nous nommerons cette 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; }
}

Dans la méthode OnStart(), nous créerons une nouvelle instance de cette classe et initialiserons ses propriétés.

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

Nous utiliserons la méthode SetObject(string key, Object object) pour enregistrer et récupérer le solde du compte.

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

Si nous construisons notre cBot et le lançons, nous devrions voir les valeurs correctes affichées dans le journal.

Portées du stockage local

Lors de l'utilisation du stockage local, vous pouvez également définir la portée dans laquelle les valeurs enregistrées sont exposées pour une récupération ultérieure. Il existe trois portées différentes disponibles :

  • Portée d'instance - les valeurs enregistrées ne sont disponibles que pour une instance spécifique.
  • Portée de type - les valeurs enregistrées sont disponibles pour toutes les instances d'un algorithme spécifique.
  • Portée d'appareil - les valeurs enregistrées sont disponibles pour tous les algorithmes, quel que soit leur type.

Voici à quoi pourrait ressembler l'utilisation de la portée d'instance.

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

Notez que nous avons explicitement spécifié la portée dans la méthode SetString().

Nous pouvons ajouter plusieurs instances de ce cBot et les configurer de sorte qu'une écrive dans le stockage local tandis qu'une autre récupère les informations. Dans ce cas, la lecture des informations devrait être impossible. Cependant, si une seule instance est configurée pour exécuter à la fois les opérations d'écriture et de lecture, le cBot devrait fonctionner comme prévu.

Voici un exemple d'utilisation de la portée de type.

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

Si nous créons deux instances de ce bot et les configurons de sorte qu'une instance écrive dans le stockage local et qu'une autre lise la valeur enregistrée, tout devrait fonctionner sans générer d'erreurs.

Enfin, la portée d'appareil permet d'échanger des informations entre différents algorithmes. Voici un exemple d'utilisation de ce type de portée.

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

Nous pouvons construire plusieurs cBots qui utilisent tous le même code. Si nous les configurons correctement, un cBot peut enregistrer des informations dans le stockage local tandis qu'un autre les récupère. Tant que la portée est égale à LocalStorageScope.Device, notre système devrait fonctionner comme prévu.

Utilisation des méthodes Flush() et Reload()

Si vous souhaitez partager des informations entre plusieurs instances de cTrader, appelez les méthodes Flush() et 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"));
    }
}

Si nous construisons plusieurs cBots avec ce code et effectuons une expérience pour partager des informations entre différentes instances de cTrader, nous verrons que nos valeurs enregistrées sont conservées comme prévu.