Como adicionar métodos à API do cTrader

Os métodos de extensão são uma ferramenta crucial se quiser adicionar nova funcionalidade à API do cTrader. Usando uma sintaxe relativamente simples, pode adicionar novos comportamentos a qualquer classe API pré-definida, como Symbol ou Position. Depois de definir um método de extensão, pode chamá-lo a partir de qualquer objeto da classe que estendeu.

Caso de uso para métodos de extensão

Primeiro, faremos uma rápida demonstração do motivo pelo qual poderá querer utilizar métodos de extensão.

Utilizando um cBot, queremos poder aceder ao tamanho de uma determinada posição em lotes, uma vez que esta informação afeta diretamente a nossa estratégia de negociação preferida. Para tal, podemos tentar inicializar uma variável da classe Position e, em seguida, tentar aceder ao seu método Lots().

1
2

Position position = Positions.Last();
Print(position.Lots());

Se simplesmente digitarmos o código como está, receberemos um erro sugerindo que o acessor Lots() não existe na API. Mas e se houvesse uma forma de adicionar um novo método a um membro da API existente sem afetar quaisquer outras funcionalidades?

Assumindo que este método existia, poderíamos ter criado um cBot simples que, a cada barra, iteraria sobre uma lista de todas as posições atuais e imprimiria o seu tamanho em lotes no registo. Definiríamos o método OnBar() da seguinte forma.

1
2
3
4
5
6

protected override void OnBar()
{
    foreach (var position in Positions) {
        Print(position.Lots());
    }
}

Os métodos de extensão permitem-nos adicionar a funcionalidade Lots() em apenas algumas linhas de código e, em seguida, reutilizá-la sempre que quisermos em qualquer objeto da classe Position. Abaixo, explicamos como pode criar um e fornecemos vários exemplos de algoritmos que os utilizam.

Como funcionam os métodos de extensão

Ao trabalhar com métodos de extensão, tenha em mente as seguintes regras.

• Os métodos de extensão são sempre estáticos.

Para declarar um método estático, tudo o que precisa de fazer é utilizar a palavra-chave static. Abaixo, declare o método Lots() com um corpo vazio.

1
2
3
4

public static class MyExtensions {
    public static double Lots() {}

}

• Os métodos de extensão podem ter qualquer número de argumentos, mas o primeiro argumento tem sempre de designar o tipo de dados/classe para o qual o método deve ser chamado, precedido pela palavra-chave this.

Adicionaremos um objeto da classe Position como o primeiro e único argumento do método Lots(). Como um objeto Position também contém informações sobre o símbolo para o qual a posição é aberta, não precisamos de quaisquer outros argumentos.

1
2
3

public static class MyExtensions {
    public static double Lots(this Position position) {}
}

• Os métodos de extensão podem conter qualquer lógica adequada para os argumentos fornecidos.

Não é necessário utilizar uma sintaxe especial ao definir o corpo de um método de extensão. Podemos tratá-lo como qualquer outro método e, portanto, podemos definir o seu corpo da seguinte forma.

1
2
3
4
5

public static class MyExtensions {
    public static double Lots(this Position position) {
        return position.VolumeInUnits / position.Symbol.LotSize;
    }
}

• Os métodos de extensão podem ser chamados como métodos de instância ou métodos estáticos.

Existem duas formas possíveis de chamar o nosso método de extensão no código de um cBot.

Ao utilizar a sintaxe do método de instância, chamamos o método a partir de qualquer objeto adequado do tipo Position.

1
2

var position = Positions.Last();
Print(position.Lots());

Ao utilizar a sintaxe do método estático, podemos chamar o nosso método de extensão após especificar completamente a sua classe estática correspondente.

1
2

var position = Positions.Last();
Print(MyExtensions.Lots(position));

Cabe a si determinar qual o método de chamada de métodos de extensão mais conveniente.

Para demonstrar o nosso novo método em ação, podemos criar um cBot que coloca três ordens no início, cada uma com um volume diferente. Em cada barra, o cBot imprime o volume de todas as posições atualmente abertas em lotes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

protected override void OnStart()
{
    ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000);
    ExecuteMarketOrder(TradeType.Buy, SymbolName, 100000);
    ExecuteMarketOrder(TradeType.Buy, SymbolName, 50000);
}

protected override void OnBar()
{
    foreach (var position in Positions) {
        Print(position.Lots());
    }
}

Após construir e lançar o nosso cBot, deveremos ver os valores corretos a serem impressos no registo.

Utilizar métodos de extensão em cBots

Agora vamos tentar criar um cBot mais complexo. Em cada barra, o nosso algoritmo percorrerá a lista de posições atualmente abertas e ajustará os seus níveis de stop-loss para que estejam no break-even. Para tal, precisaremos de criar um método de extensão BreakEven() para a classe Position.

Criamos um novo cBot e renomeamo-lo. Depois, apagamos todo o código de que não precisamos e adicionamos a classe MyExtensions.

1
2
3

public static class MyExtensions {

}

O nosso código para o método BreakEven() é relativamente simples. Verificamos se uma posição tem um stop loss, se o seu lucro bruto é superior a zero e se o stop loss atualmente definido não é igual ao preço de entrada da posição. Se todas estas condições forem verdadeiras, modificamos o stop loss da posição para que seja igual ao preço de entrada da posição.

1
2
3
4
5
6
7

public static class MyExtensions {
    public static void BreakEven(this Position position) {
        if (position.StopLoss is not null && position.GrossProfit > 0 && position.StopLoss != position.EntryPrice) {
            position.ModifyStopLossPrice(position.EntryPrice);
        }
    }
}

No próprio cBot, não precisamos de utilizar nenhum método além do OnBar(). Em cada barra, pedimos ao cBot para realizar uma operação simples, nomeadamente iterar sobre a coleção Positions e chamar o novo método BreakEven() para cada elemento nela.

1
2
3
4
5
6

protected override void OnBar() 
{
    foreach (var position in Positions) {
        position.BreakEven();
    }
}

Depois de construirmos e lançarmos o nosso cBot, podemos vê-lo em ação. Pode ser um assistente de negociação útil, especialmente ao gerir muitas posições abertas.

Utilizar métodos de extensão em indicadores

Também criaremos um indicador útil que depende de métodos de extensão. O indicador medirá a volatilidade, traçando a percentagem pela qual o preço de um símbolo mudou em cada barra em comparação com o preço de abertura dessa barra.

Para tal, criaremos um novo indicador e renomeá-lo-emos. Na janela do editor de código, criaremos a classe MyExtensions para estender a classe Bar.

1
2
3

public static class MyExtensions {

}

Também adicionaremos o método PercentageChange(). Na variável priceChange, subtraímos o preço de fecho de uma barra do seu preço de abertura. O método retorna a nossa variação de preço dividida pelo preço de abertura e multiplicada por 100.

1
2
3
4
5
6
7
8

public static class MyExtensions 
{
    public static double PercentageChange(this Bar bar) 
    {
        var priceChange = bar.Open - bar.Close;
        return priceChange / bar.Open * 100;
    }
}

No próprio código do indicador, não temos necessidade do método Initialize() e de parâmetros desnecessários. No corpo do método Calculate(), simplesmente chamamos o nosso novo método PercentageChange() em cada barra.

1
2
3
4
5
6
7
8

[Output("Main")]
public IndicatorDataSeries Result { get; set; }


public override void Calculate(int index)
{
    Result[index] = Bars[index].PercentageChange();
}

Depois, guardamos e construímos o nosso indicador. Após criar uma instância do mesmo, deveremos ver as alterações percentuais corretas a serem traçadas. Estas podem ser utilizadas para determinar a volatilidade a curto e longo prazo, beneficiando todos os tipos de estratégias de negociação.

Resumo

Para concluir, os métodos de extensão são uma ferramenta valiosa se quiser criar código reutilizável que adicione novas funcionalidades à API do cTrader. Recomendamos vivamente que experimente os métodos de extensão, pois podem tornar os seus algoritmos mais eficientes e mais fáceis de manter.