Przejdź do treści

Jak pracować z lokalnym przechowywaniem danych

W tym artykule i odpowiadającym mu filmie wyjaśnimy, czym jest lokalne przechowywanie danych i jak można go używać w algorytmach cTrader. Podamy również przydatne przykłady i wyjaśnimy, jak działa zakres lokalnego przechowywania danych.

Dlaczego warto używać lokalnego przechowywania danych

Istnieje wiele przypadków, w których chcesz, aby Twój algorytm zapisywał coś w lokalnym systemie plików lub uzyskiwał do niego dostęp. Na przykład możesz chcieć zapisać dziennik wszystkich operacji cBota. Jednak zwykle wymaga to, aby algorytm miał podwyższone prawa dostępu (AccessRights.FullAccess), co jest mniej niż idealne dla użytkowników. Jeśli algorytm żąda od użytkownika zapewnienia podwyższonych uprawnień, użytkownik jest znacznie mniej skłonny zaufać algorytmowi, zwłaszcza jeśli jest on dystrybuowany bez kodu źródłowego. Lokalne przechowywanie danych to wygodny sposób na bezpieczny dostęp do lokalnego systemu plików bez wprowadzania jakichkolwiek obaw dotyczących bezpieczeństwa. Korzystanie z lokalnego przechowywania danych pozwala programistom zachować prawa dostępu swoich algorytmów ustawione na AccessRights.None.

Zapisywanie ciągów znaków w lokalnym przechowywaniu danych

Każdy typ algorytmu cTrader ma właściwość LocalStorage, która umożliwia wykonywanie operacji odczytu i zapisu. Aby zademonstrować, jak działa lokalne przechowywanie danych, utworzymy nowego cBota. W jego procedurze obsługi OnStart użyjemy metody LocalStorage.SetString(string key, string value). Jak widać, przyjmuje ona dwa argumenty, a mianowicie klucz, pod którym informacje powinny zostać zapisane, oraz wartość do zapisania.

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

Aby pobrać wartość, użyjemy metody GetString(string key) w procedurze obsługi OnTick cBota.

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

Dopóki Message nie jest null, możemy skompilować cBota i zobaczyć, jak pobrana wartość jest poprawnie drukowana w dzienniku.

Zapisywanie obiektów w lokalnym przechowywaniu danych

Oprócz ciągów znaków możesz używać lokalnego przechowywania danych do zapisywania dowolnego rodzaju obiektów. W tle cTrader serializuje i deserializuje obiekty w lokalnym przechowywaniu danych, co umożliwia udostępnianie dowolnego rodzaju danych. Aby to zademonstrować, możemy utworzyć nową klasę do przechowywania informacji, zapisać ją, a następnie odzyskać. Nazwiemy tę klasę Signal.

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

W metodzie OnStart() utworzymy nowe wystąpienie tej klasy i zainicjalizujemy jej właściwości.

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

Użyjemy metody SetObject(string key, Object object) do zapisania i odzyskania salda konta.

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

Jeśli zbudujemy naszego cBota i uruchomimy go, powinniśmy zobaczyć prawidłowe wartości wyświetlane w dzienniku.

Zakresy pamięci lokalnej

Podczas korzystania z pamięci lokalnej możesz również zdefiniować zakres, w którym zapisane wartości są udostępniane do przyszłego odzyskania. Dostępne są trzy różne zakresy:

  • Zakres wystąpienia - zapisane wartości są dostępne tylko dla konkretnego wystąpienia.
  • Zakres typu - zapisane wartości są dostępne dla wszystkich wystąpień określonego algorytmu.
  • Zakres urządzenia - zapisane wartości są dostępne dla wszystkich algorytmów niezależnie od ich typów.

Oto jak może wyglądać użycie zakresu wystąpienia.

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

Zwróć uwagę, że jawnie określiliśmy zakres w metodzie SetString().

Możemy dodać kilka wystąpień tego cBota i skonfigurować je tak, aby jedno zapisywało do pamięci lokalnej, a drugie odzyskiwało informacje. W tym przypadku odczytanie informacji powinno być niemożliwe. Jeśli jednak tylko jedno wystąpienie zostanie skonfigurowane do wykonywania zarówno operacji zapisu, jak i odczytu, cBot powinien działać zgodnie z przeznaczeniem.

Oto przykład użycia zakresu typu.

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

Jeśli utworzymy dwa wystąpienia tego bota i skonfigurujemy je tak, aby jedno wystąpienie zapisywało do pamięci lokalnej, a drugie odczytywało zapisaną wartość, wszystko powinno działać bez wywoływania błędów.

Wreszcie, zakres urządzenia umożliwia wymianę informacji między różnymi algorytmami. Oto przykład użycia tego typu zakresu.

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

Możemy zbudować kilka cBotów, które wszystkie używają tego samego kodu. Jeśli skonfigurujemy je prawidłowo, jeden cBot może zapisywać informacje do pamięci lokalnej, podczas gdy inny je odzyskuje. Dopóki zakres jest równy LocalStorageScope.Device, nasz system powinien działać zgodnie z przeznaczeniem.

Używanie metod Flush() i Reload()

Jeśli chcesz udostępniać informacje między kilkoma wystąpieniami cTrader, wywołaj metody Flush() i 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"));
    }
}

Jeśli zbudujemy kilka cBotów z tym kodem i przeprowadzimy eksperyment polegający na udostępnianiu informacji między różnymi wystąpieniami cTrader, zobaczymy, że nasze zapisane wartości są utrwalane zgodnie z przeznaczeniem.