Zum Inhalt

Wie man mit lokalem Speicher arbeitet

In diesem Artikel und dem dazugehörigen Video werden wir erklären, was lokaler Speicher ist und wie er in Ihren cTrader-Algos verwendet werden kann. Wir werden auch nützliche Beispiele bereitstellen und erklären, wie der Geltungsbereich des lokalen Speichers funktioniert.

Warum lokalen Speicher verwenden

Es gibt viele Fälle, in denen Sie möchten, dass Ihr Algo etwas im lokalen Dateisystem speichert oder darauf zugreift. Sie möchten beispielsweise ein Protokoll aller cBot-Vorgänge speichern. Dies erfordert jedoch in der Regel, dass der Algorithmus über erweiterte Zugangsrechte (AccessRights.FullAccess) verfügt, was für Benutzer nicht ideal ist. Wenn ein Algorithmus einen Benutzer auffordert, erweiterte Berechtigungen zu erteilen, ist es viel unwahrscheinlicher, dass der Benutzer dem Algorithmus vertraut, insbesondere wenn er ohne Quellcode verteilt wird. Der lokale Speicher ist eine bequeme Möglichkeit, sicher auf das lokale Dateisystem zuzugreifen, ohne Sicherheitsbedenken hervorzurufen. Die Verwendung des lokalen Speichers ermöglicht es Entwicklern, die Zugangsrechte ihrer Algorithmen auf AccessRights.None zu belassen.

Strings im lokalen Speicher speichern

Jeder Typ von cTrader-Algorithmus verfügt über eine LocalStorage-Eigenschaft, die das Ausführen von Lese- und Schreibvorgängen ermöglicht. Um zu demonstrieren, wie der lokale Speicher funktioniert, erstellen wir einen neuen cBot. In seinem OnStart-Handler verwenden wir die Methode LocalStorage.SetString(string key, string value). Wie Sie sehen können, benötigt sie zwei Argumente, nämlich einen Schlüssel, unter dem die Informationen gespeichert werden sollen, und den zu speichernden Wert.

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

Um den Wert abzurufen, verwenden wir die Methode GetString(string key) im OnTick-Handler des cBots.

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

Solange Message nicht null ist, können wir den cBot erstellen und sehen, wie der abgerufene Wert korrekt im Protokoll ausgegeben wird.

Objekte im lokalen Speicher speichern

Neben Strings können Sie den lokalen Speicher verwenden, um jede Art von Objekt zu speichern. Im Hintergrund serialisiert und deserialisiert cTrader Objekte im lokalen Speicher, was die Freigabe jeder Art von Daten ermöglicht. Um dies zu demonstrieren, können wir eine neue Klasse erstellen, um Informationen zu speichern, sie zu speichern und später abzurufen. Wir nennen diese Klasse Signal.

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

In der Methode OnStart() erstellen wir eine neue Instanz dieser Klasse und initialisieren ihre Eigenschaften.

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

Wir verwenden die Methode SetObject(string key, Object object), um den Kontostand zu speichern und abzurufen.

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

Wenn wir unseren cBot erstellen und starten, sollten wir sehen, wie die korrekten Werte im Protokoll ausgegeben werden.

Geltungsbereiche des lokalen Speichers

Bei der Verwendung des lokalen Speichers können Sie auch den Geltungsbereich definieren, in dem die gespeicherten Werte für den späteren Abruf verfügbar gemacht werden. Es stehen drei verschiedene Geltungsbereiche zur Verfügung:

  • Instanzbereich – gespeicherte Werte sind nur für eine bestimmte Instanz verfügbar.
  • Typbereich – gespeicherte Werte sind für alle Instanzen eines bestimmten Algorithmus verfügbar.
  • Gerätebereich – gespeicherte Werte sind für alle Algorithmen unabhängig von ihren Typen verfügbar.

So könnte die Verwendung des Instanzbereichs aussehen.

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

Beachten Sie, dass wir den Geltungsbereich in der Methode SetString() explizit angegeben haben.

Wir können mehrere Instanzen dieses cBots hinzufügen und sie so konfigurieren, dass eine in den lokalen Speicher schreibt, während eine andere Informationen abruft. In diesem Fall sollte das Lesen von Informationen unmöglich sein. Wenn jedoch nur eine Instanz so eingerichtet ist, dass sie sowohl Schreib- als auch Lesevorgänge ausführt, sollte der cBot wie vorgesehen funktionieren.

Hier ist ein Beispiel für die Verwendung des Typbereichs.

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

Wenn wir zwei Instanzen dieses Bots erstellen und sie so einrichten, dass eine Instanz in den lokalen Speicher schreibt und eine andere den gespeicherten Wert liest, sollte alles ohne Fehler funktionieren.

Zu guter Letzt ermöglicht der Gerätebereich den Informationsaustausch zwischen verschiedenen Algorithmen. Hier ist ein Beispiel für die Verwendung dieses Geltungsbereichstyps.

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

Wir können mehrere cBots erstellen, die alle denselben Code verwenden. Wenn wir sie richtig einrichten, kann ein cBot Informationen im lokalen Speicher speichern, während ein anderer sie abruft. Solange der Geltungsbereich gleich LocalStorageScope.Device ist, sollte unser System wie vorgesehen funktionieren.

Verwendung der Methoden Flush() und Reload()

Wenn Sie Informationen zwischen mehreren Instanzen von cTrader austauschen möchten, rufen Sie die Methoden Flush() und Reload() auf.

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

Wenn wir mehrere cBots mit diesem Code erstellen und ein Experiment durchführen, um Informationen zwischen verschiedenen Instanzen von cTrader auszutauschen, werden wir sehen, dass unsere gespeicherten Werte wie vorgesehen beibehalten werden.