Ir para o conteúdo

Como trabalhar com armazenamento local

Neste artigo e no vídeo correspondente, explicaremos o que é o armazenamento local e como pode ser utilizado nos seus algos do cTrader. Também forneceremos exemplos úteis e explicaremos como funciona o âmbito do armazenamento local.

Por que usar o armazenamento local

Existem muitos casos em que pretende que o seu algoritmo guarde algo ou aceda a algo do sistema de ficheiros local. Por exemplo, pode querer guardar um registo de todas as operações do cBot. No entanto, isto geralmente requer que o algoritmo tenha direitos de acesso elevados (AccessRights.FullAccess), o que é menos do que ideal para os utilizadores. Se um algoritmo solicitar a um utilizador que forneça permissões elevadas, é muito menos provável que o utilizador confie no algoritmo, especialmente se for distribuído sem o seu código-fonte. O armazenamento local é uma forma conveniente de aceder com segurança ao sistema de ficheiros local sem introduzir quaisquer preocupações de segurança. Usar o armazenamento local permite aos programadores manter os direitos de acesso dos seus algoritmos definidos como AccessRights.None.

Guardar strings no armazenamento local

Cada tipo de algoritmo cTrader tem uma propriedade LocalStorage que permite executar operações de leitura e escrita. Para demonstrar como funciona o armazenamento local, vamos criar um novo cBot. No seu manipulador OnStart, usaremos o método LocalStorage.SetString(string key, string value). Como pode ver, este método recebe dois argumentos, nomeadamente uma chave sob a qual a informação deve ser guardada e o valor a ser guardado.

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

Para recuperar o valor, usaremos o método GetString(string key) no manipulador OnTick do cBot.

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

Desde que Message não seja nulo, podemos compilar o cBot e ver o valor recuperado a ser corretamente impresso no registo.

Guardar objetos no armazenamento local

Para além de strings, pode usar o armazenamento local para guardar qualquer tipo de objeto. Nos bastidores, o cTrader serializa e desserializa objetos no armazenamento local, o que permite partilhar qualquer tipo de dados. Para demonstrar isto, podemos criar uma nova classe para armazenar informações, guardá-la e posteriormente recuperá-la. Vamos chamar a esta 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; }
}

No método OnStart(), criaremos uma nova instância desta classe e inicializaremos as suas propriedades.

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

Usaremos o método SetObject(string key, Object object) para guardar e recuperar o saldo da conta.

 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 compilarmos o nosso cBot e o iniciarmos, deveremos ver os valores corretos a serem impressos no registo.

Âmbitos do armazenamento local

Ao usar o armazenamento local, também pode definir o âmbito no qual os valores guardados são expostos para recuperação futura. Existem três âmbitos diferentes disponíveis:

  • Âmbito de instância - os valores guardados estão disponíveis apenas para uma instância específica.
  • Âmbito de tipo - os valores guardados estão disponíveis para todas as instâncias de um algoritmo específico.
  • Âmbito de dispositivo - os valores guardados estão disponíveis para todos os algoritmos, independentemente dos seus tipos.

Eis como poderia ser o uso do âmbito de instância.

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

Note que especificámos explicitamente o âmbito no método SetString().

Podemos adicionar várias instâncias deste cBot e configurá-las de modo que uma escreva no armazenamento local enquanto outra recupera informações. Neste caso, a leitura de informações deve ser impossível. No entanto, se apenas uma instância estiver configurada para executar operações de escrita e leitura, o cBot deve funcionar como pretendido.

Aqui está um exemplo de uso do âmbito de 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 criarmos duas instâncias deste bot e as configurarmos de modo que uma instância escreva no armazenamento local e outra leia o valor guardado, tudo deve funcionar sem gerar quaisquer erros.

Por último, mas não menos importante, o âmbito de dispositivo permite trocar informações entre diferentes algoritmos. Aqui está um exemplo de uso deste tipo de âmbito.

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

Podemos compilar vários cBots que usam todos o mesmo código. Se os configurarmos corretamente, um cBot pode guardar informações no armazenamento local enquanto outro as recupera. Desde que o âmbito seja igual a LocalStorageScope.Device, o nosso sistema deve funcionar como pretendido.

Usar os métodos Flush() e Reload()

Se quiser partilhar informações entre várias instâncias do cTrader, chame os métodos 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 compilarmos vários cBots com este código e realizarmos uma experiência para partilhar informações entre diferentes instâncias do cTrader, veremos que os nossos valores guardados são persistidos como pretendido.