Desenvolvendo um sistema de Replay (Parte 48): Entendendo e compreendendo alguns conceitos

Introdução

No artigo anterior Desenvolvendo um sistema de Replay (Parte 47): Projeto do Chart Trade (VI), acabamos por tornar o indicador Chart Trade em algo funcional. Então podemos voltar a focar no que realmente precisamos desenvolver.

Lá no início desta sequência de artigos sobre o sistema de replay / simulador. Tentei por algum tempo, fazer com que o serviço conseguisse colocar o indicador de controle no gráfico. Apesar de não estar conseguindo fazer isto lá no início, não desistir e continuei tentando. Apesar de diversas tentativas terem falhado, não estava de forma alguma, conseguindo ter sucesso em efetuar tal coisa. E como o projeto não podia ficar parado. Decidi, na época, tocar as coisas de outra maneira.

No entanto o que me atormentava, era o fato de que conseguia fazer as coisas utilizando um script, mas quanto tentava fazer isto usando um serviço, não conseguia de modo algum que fazer com que a coisa viesse a funcionar como esperado.

Bem, mas aí você pode pensar: E daí ?! A questão de conseguir fazer isto usando um script, não significa nada. No entanto, se você pensa assim, devo lhe pedir desculpas por sua falta de conhecimento em programação MQL5. Qualquer script criado em MQL5, pode ser transformado em um serviço. Existe basicamente duas diferenças entre um serviço e um script. Apesar de existirem mais, duas são mais evidentes e podem ser notadas por qualquer um.

A primeira diferença é o fato de que o script, fica sempre atrelado a um determinado gráfico. E fica ali até que o gráfico seja fechado. Detalhe: Quando você troca o tempo gráfico, o MetaTrader 5, na verdade envia um comando, que faz com que o gráfico seja redesenhado. Mas para fazer isto mais rapidamente, ele fecha o objeto gráfico ( NÃO A JANELA, mas sim o objeto presente na janela ) e abre um novo objeto. Assim algumas é possível redesenhar rapidamente o gráfico. No entanto ao fazer isto, o script não retorna para o gráfico, já que ele não conta com esta capacidade, por não ter certos eventos nele.

Então caso você deseje que algo, que seria um script, permaneça observando o gráfico, você não poderá usá-lo diretamente no gráfico. A forma de fazer, isto é, usando algo fora do gráfico. No entanto, capaz de observar o gráfico. Isto parece ser muito complicado e confuso. Mas em grande parte das vezes você consegue fazer isto, modificando alguns detalhes no código. e tornando um script em um serviço. Assim sendo um serviço ele deixará de ficar atrelado a um gráfico, mas poderá continuar a observar o gráfico do ativo.

Talvez você não consiga de fato entender, a lógica e o motivo pelo qual isto deveria acontecer. Mas sem conseguir de fato fazer isto, não será possível efetuar as próximas etapas que teremos que fazer. Então fazer com que um serviço consiga observar o que está acontecendo em um gráfico, especifico, é extremamente importante para o que precisaremos fazer em breve. Não pelo fato de que teremos que construir, mas sim pelo fato do que precisaremos observar.

Então utilize este artigo como um recurso de pesquisa, pois o conteúdo presente nele será extremamente necessário para o sistema de replay / simulação. Mas além disto você pode contar com um aprendizado que irá fazer toda a diferença em projetos muito mais complexos e elaborados. Onde precisamos analisar o gráfico, mas não podemos nos ligar a ele.

Implementando o script de exemplo

Para compreender de fato como a coisa funciona e o nível do desafio a qual teremos que enfrentar. Vamos começar com um exemplo bem simples. No entanto ele será funcional, podendo assim server de âncora para algo ainda mais complicado que de fato será implementado depois.

Vamos começar entendendo a coisa no seu nível mais básico. Então iremos usar primeiramente um script. Bem, mas bem simples. Este pode ser visto logo abaixo:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property version   "1.00"
04. //+------------------------------------------------------------------+
05. void OnStart()
06. {
07.     long id;
08.     string szSymbol;
09.     int handle;
10.     bool bRet;
11.     ENUM_TIMEFRAMES tf;
12.     
13.     id = ChartID();
14.     szSymbol = ChartSymbol(id);
15.     tf = ChartPeriod(id);
16.     handle = iMA(szSymbol, tf, 9, 0, MODE_EMA, PRICE_CLOSE);
17.     bRet = ChartIndicatorAdd(id, 0, handle);
18.     
19.     Print(ChartIndicatorName(id, 0, 0), " ", szSymbol, " ", handle, "  ", bRet, " >> ",id);
20.     
21.     Print("*******");
22. }
23. //+------------------------------------------------------------------+

Código fonte do script de exemplo

Sei que este script é super simples, mas ele irá servir para que eu possa explicar o que de fato iremos fazer. Observe que nas linhas 02 e 03 temos dados sobre as propriedades do código. Bem, estas não são tão importantes para a nossa explicação. Mas na linha 05 começamos de fato o nosso código. Já que se trata de um script, e este é super mega simples, a única função que realmente se faz necessária é a OnStart.

Muito bem. Entre as linhas 07 a linha 11, temos as nossas variáveis locais. Aqui é preciso que você note uma coisa importante. Não precisamos de fato de todas estas variáveis em um script. Não para o que iremos fazer. Na verdade, não precisaríamos de nenhuma destas variáveis. Mas por conta da linha 19, estaremos usando-as aqui no script.

O que de fato acontece, aqui no script é o seguinte: Na linha 13 capturamos a ID do gráfico no qual o script será colocado. Logo depois, na linha 14, pegamos o nome do ativo que se encontra neste gráfico. Na linha 15, fazemos a captura do tempo gráfico, no qual o nosso script estará sendo executado. Todos estes 3 passos são de fato desnecessários. Apesar do passo na linha 13 ser necessário, os passos presentes na linha 14 e 15, não se faz necessários para um script. Mas depois irá ficar claro o porquê de estes passos existirem aqui.

Na linha 16, iremos fazer com que o MetaTrader 5, coloque no gráfico um dos indicadores técnicos que fazem parte da plataforma. No caso uma média móvel. Agora observem o seguinte: A média móvel que estará sendo adicionada será uma de 9 períodos e do tipo exponencial. Tendo os seus valores sendo calculados com base no preço de fechamento. Se tudo estiver correto, este indicador irá retornar um handle.

Na linha 17, usamos o handle que foi criado na linha 16, e dizemos ao MetaTrader 5, que o indicador a qual o handle pertence deverá ser lançado na tela do gráfico. Já na linha 19 imprimimos todos os valores que foram capturados e usados pelo script. Isto seria uma forma de debugar o mesmo. Mas também serve para uma outra coisa que iremos ver em breve.

Observem que tudo que fizemos poderia ser feito de diversas outras formas. Você com certeza deve estar pensando: Que código inútil. Por que alguém criaria algo assim ?! De fato, não lhe repreendo por pensar assim. Mas em se tratando de programação, nem tudo é de fato inútil. Salvo o fato de você criar algo sem nenhum tipo de propósito.

Se você compilar este script e o jogar no gráfico, irá ver que será apresentado uma média móvel, de 9 períodos, cujo cálculo é baseado no preço de fechamento. Já que o código do script entra e sai muito rapidamente, e praticamente ele é voltado para testarmos uma outra coisa. Ele não tem nenhum tipo de verificação de erro. Qualquer erro que venha a acontecer, será notado ao se observar a caixa de mensagens do MetaTrader 5.

Agora que a coisa de fato começa a ficar interessante: Então vamos pensar o seguinte: Se modificarmos a linha 16 por uma outra como por exemplo:

handle = iCustom(szSymbol, tf, "Replay\\Chart Trade.ex5", id);

Poderemos fazer com que o nosso indicador Chart Trade, seja colocado no gráfico pelo script. Mas você ainda deve estar pensando qual a real utilidade disto. Mas como foi dito no início deste artigo, a coisa de fato, passa a ser interessante quando começamos a usar este script, não mais como script e sim como serviço.

Tornando um script em um serviço

Tornar um script em um serviço não é uma das coisas mais complicadas. Pelo menos a princípio. Isto por que basicamente a única diferença que de fato existe no código é o uso de uma propriedade que informa que o script é na verdade um serviço. Basicamente é isto. Mas apesar de parecer simples assim, existem alguns detalhes que você precisa entender e aprender para de fato conseguir fazer isto da forma correta.

Vamos voltar ao nosso exemplo visto no tópico anterior. Se você tentar transformar aquele script em serviço, mantendo o código intacto, mas adicionando a propriedade que informa que se trata de um serviço, irá notar que não é possível fazer com que as coisas aconteçam. Mas por que ?!

O motivo é que diferente do script, um serviço não está de fato atrelado a um gráfico. E o fato de isto acontecer, torna as coisas um pouco mais complicadas.

Para simplificar um pouco as coisas, vamos primeiramente entender como o MetaTrader 5 trabalha. Vamos iniciar a plataforma com nenhum gráfico aberto. Ou seja, podemos adicionar serviços, mas não podemos fazer nada mais do que isto. A partir do momento que você adiciona o primeiro gráfico, podemos começar a colocar indicador, script e Expert Advisor no gráfico. Mas também podemos fazer algumas manipulações no gráfico usando para isto um serviço.

Você provavelmente nunca deve ter tentado fazer isto, ou visto alguém fazer tal coisa. Até agora. Mas sim você pode fazer com que o serviço coloque certas coisas no gráfico, nós vamos chegar lá, mas vamos com calma. Pois se esta base que estou querendo mostrar, não for adequadamente e bem compreendida, você ficará completamente sem entender todos os meus novos artigos, pois irei fazer uso massivo deste tipo de coisa, a fim de agilizar e facilitar outras coisas.

Então conforme você vai adicionado gráfico, após gráfico no MetaTrader 5, e não fecha os gráficos anteriores, vai se criando uma fila de gráfico. Pois bem, a ordem com que eles irão ser acessados, não é a ordem que você os organizou no terminal MetaTrader 5. A ordem será a ordem com que eles foram sendo abertos. Este é o primeiro ponto. Felizmente o MQL5, nos dá meios de navegar nesta lista de gráficos, e isto será importante para nós.

Então se você deseja, ao invés de construir um template, criar uma forma de adicionar indicadores específicos em ativos específicos, e isto de modo simplificado, deverá fazer uso de um serviço. Parece complicado ?! Bem, na verdade não é assim tão complicado. Não se você conseguir de fato compreender o que está acontecendo.

Vamos voltar ao código presente no tópico anterior, onde adicionávamos uma média móvel exponencial de 9 períodos usando um script. Mas agora queremos fazer com que no momento que o primeiro gráfico seja aberto, este receba esta média móvel. Independentemente de qual seja o ativo. O importante é que ele seja o primeiro gráfico a ser aberto. Com isto precisaremos que aquele mesmo script, seja modificado para o código de serviço visto logo abaixo. 

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property version   "1.00"
05. //+------------------------------------------------------------------+
06. void OnStart()
07. {
08.     long id;
09.     string szSymbol;
10.     int handle;
11.     bool bRet;
12.     ENUM_TIMEFRAMES tf;
13.     
14.     Print("Waiting for the chart of the first asset to be opened...");
15.     while ((id = ChartFirst()) < 0);
16.     szSymbol = ChartSymbol(id);
17.     tf = ChartPeriod(id);
18.     handle = iMA(szSymbol, tf, 9, 0, MODE_EMA, PRICE_CLOSE);
19.     bRet = ChartIndicatorAdd(id, 0, handle);
20.     
21.     Print(ChartIndicatorName(id, 0, 0), " ", szSymbol, " ", handle, "  ", bRet, " >> ",id);
22.     
23.     Print("*******");
24. }
25. //+------------------------------------------------------------------+

Código fonte do Serviço

Observe com atenção este código visto logo acima. Compare ele com o código visto no tópico anterior. Agora responda: Qual a diferença entre eles ?! Bem, provavelmente você irá dizer que é a linha 02, onde existe agora uma propriedade que define este código como sendo um serviço. De fato, isto é verdade, mas além disto ?! Bem, também temos a presença de duas linhas diferentes. A linha 14, onde imprimimos uma mensagem informando que o serviço está esperando um gráfico ser colocado no terminal do MetaTrader 5. E a linha 15, onde ficamos aguardando este gráfico de fato ser aberto.

Veja como a coisa aqui começa a ficar bem mais interessante. Para entender o que de fato está acontecendo. Digite este código acima e o compile usando o MetaEditor. Abra o MetaTrader 5, logo depois feche todos, mas absolutamente todos os gráficos que estão presentes e se encontram abertos. Depois disto, vá e inicialize o serviço que acabamos de construir. Abra a caixa de mensagens, e você poderá ver a mensagem que é vista na linha 14. Se isto acontecer significa que você fez tudo corretamente. Agora abra um gráfico de algum ativo. Você irá ver no mesmo instante, a mensagem presente na linha 21, e o serviço sendo encerrado. Mas ao observar o gráfico irá notar que ele contém a média móvel exponencial de 9 períodos, assim como era esperado. Isto por que o serviço a colocou ali.

Muito bem, espero que você, caro leitor esteja conseguindo acompanhar o que está sendo explicado, pois agora vamos complicar a coisa mais um pouco.

Garantindo um gráfico padronizado:

A parte que realmente mais interessante no uso de serviços, começa a partir de agora. Muita gente costuma gostar de usar um modelo gráfico padronizado, criando para isto templates. O template default de certa forma nos ajuda justamente nisto. Ele garante que todos os gráficos terão um padrão no momento que ele for criado. Mas uma vez que o template tenha sido colocado, podemos sem querer remover algum indicador, ou mudar a configuração de algum dos indicadores. Em diversos casos isto não é de fato um problema. Você pode simplesmente repor o indicador e ponto final. Mas será que podemos usar o MetaTrader 5 de forma que ele não nos deixe na mão ?! Fazendo com que tenhamos sempre algo muito próximo do que seria um terminal Bloomberg ?!

Sim é possível fazer isto. Podemos de fato impedir que o usuário, ou nos mesmos, venhamos a desconfigurar algo no terminal. Neste caso especifico estou falando de indicadores. Em artigos passados, mostrei como você pode forçar o sistema a manter este ou aquele indicador no gráfico. Isto tem sido feito, a um bom tempo neste sistema de replay / simulador, a fim de evitar que o Indicador de controle não seja removido do gráfico. Mas existe uma solução mais versátil, que permite você manter qualquer coisa no gráfico, ou evitar que outras venham a aparecer no gráfico.

Com relação a evitar, acredito não fazer muito sentido mostrar como fazer isto, mas com relação a manter, acredito de fato ser algo interessante. Então modificando mais uma vez o código visto no tópico anterior. Iremos ter o código visto logo abaixo: 

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property version   "1.00"
05. //+------------------------------------------------------------------+
06. void OnStart()
07. {
08.     long id;
09.     string szSymbol;
10.     int handle;
11.     
12.     Print("Waiting for the chart of the first asset to be opened...");
13.     while (!_StopFlag)
14.     {
15.             while (((id = ChartFirst()) < 0) && (!_StopFlag));
16.             while ((id > 0) && (!_StopFlag))
17.             {
18.                     if (ChartIndicatorName(id, 0, 0) != "MA(9)")
19.                     {
20.                             handle = iMA(szSymbol = ChartSymbol(id), ChartPeriod(id), 9, 0, MODE_EMA, PRICE_CLOSE);
21.                             ChartIndicatorAdd(id, 0, handle);
22.                             IndicatorRelease(handle);
23.                     }
24.                     id = ChartNext(id);
25.             }
26.             Sleep(250);
27.     }
28.     Print("Service finish...");
29. }
30. //+------------------------------------------------------------------+

Código do Serviço melhorado.

Você pode notar que este código contém algumas coisas que parecem estranhas. No entanto, cada uma das coisas presentes nele tem seu motivo e justificativa de estarem ali. Ele em si não é muito diferente do código visto no tópico anterior. Mas ele consegue fazer algo um tanto quanto curioso. Então vamos entender o que este código está fazendo, assim você poderá adaptar ele para as suas próprias necessidades e interesse.

Na linha 12, imprimimos uma mensagem que indicada que o serviço se encontra em modo de espera. Assim como na linha 28, informamos que o serviço foi removido, e não se encontra mais em execução. Tudo que acontece no meio destas duas linhas é o que de fato nos interessa. Para garantir que o serviço seja encerrado de maneira adequada e sem trazer problemas ao MetaTrader 5, testamos a constante _StopFlag, esta terá um valor verdadeiro, enquanto não pedimos para que o serviço seja encerrado.

Assim sendo, na linha 13 entrando em um loop infinito. Este loop de fato não é infinito, já que no momento em que informamos que desejamos encerrar o serviço, este loop será encerrado.

Já na linha 15, temos o mesmo que tínhamos no código anterior. Mas agora adicionamos um teste a fim de evitar que tenhamos problemas no encerramento do serviço. Agora preste atenção: Quando ChartFirst retorna um valor, este será o valor da primeira janela que você abriu no terminal MetaTrader 5. Este valor estará na variável id. Lembre-se deste fato, pois é importante notar a sequência das coisas a partir deste ponto.

Na linha 18, verificamos se a janela que estamos testando, contém um indicador iMA, sendo ele uma média de 9 períodos. Se esta condição não for satisfeita, ou seja, a média não existe no gráfico, iremos executar a colocação dela. Isto é feito primeiro gerando um handle, na linha 20, logo depois na linha 21 adicionamos a média ao gráfico. E assim que isto for feito, removemos o handle, já que não precisamos mais dele. Desta maneira, se você remover a média do gráfico, esta será recolocada novamente no gráfico. Isto automaticamente será feito pelo serviço, enquanto ele estiver em execução.

Já a linha 24 irá procurar a próxima janela. Agora observe que precisamos do index da janela atual, para que o MetaTrader 5 consiga saber qual será o próximo index. Não confunda as coisas. Caso uma outra janela seja encontrada, o laço irá se repetir. Até que ChartNext retorne o valor de -1. Quando o laço que se iniciou na linha 16 irá ser encerrado.

Pois bem, não precisamos que o serviço execute como um alucinado sem noção. Então na linha 26, geramos um pequeno retardo de aproximadamente 250 milissegundos até a próxima interação dos laços. Desta forma o serviço irá executar 4 vezes a cada segundo. Garantindo que a média móvel especificada esteja sempre presente em qualquer um dos gráficos, que possam estar abertos no terminal MetaTrader 5. Muito legal este tipo de coisa, não é mesmo ?!

Mas podemos fazer um pouco mais do que isto. Podemos forçar as coisas a serem colocadas em um gráfico especifico, de um ativo especifico. Este tipo de coisa é justamente o que no começo desta sequência de artigo tentei por diversas vezes conseguir fazer. Mas por um motivo ou outro não estava conseguindo fazer. Mas vamos supor que você, que esteja operando na B3 ( Bolsa do Brasil ) decida que precisa usar um dado indicador em apenas e somente em um ativo especifico. E sempre neste ativo. Uma forma de fazer isto seria usando um template. Mas é muito provável que você na correria do dia a dia acabe fechando este ativo, e ao abrir novamente o gráfico do mesmo, não note que o tão indicador está ali, até ser tarde demais.

Fazendo uso desta técnica de controle via serviço, isto não irá acontecer, pois assim que o gráfico do ativo for aberto no terminal do MetaTrader 5, o serviço se encarregará de colocar o indicador no gráfico. E se a ideia é usar um template para adicionar mais coisas, você também poderá fazer isto. Mas o uso do template será visto em outra oportunidade. Já que ele envolve algumas coisas que serão vistas nos próximos artigos desta sequência.

Então vamos ver como fazer isto. Mas para não confundir as coisas vamos ver isto em um novo tópico.

 

Garantindo um terminal de qualidade

Se você achou interessante o que foi visto no tópico anterior, prepare-se pois neste a coisa será ainda mais interessante. Já que poderemos fazer exatamente aquilo que foi dito no tópico anterior, ou seja poderemos fazer com que o gráfico de um ativo fique sempre igual a um terminal pré configurado. Mais ou mesmos como se conseguíssemos tornar o MetaTrader 5 algo parecido com o Terminal Bloomberg. Mas com uma vantagem: A configuração nunca irá ser modificada de forma acidental, isto por que ela não estará ligada a um template, e sim a uma configuração presente no serviço.

Para exemplificar as coisas, vamos ver como o código do serviço visto no tópico anterior, foi modificado a fim de promover o que desejamos. Este código modificado, pode ser visto logo abaixo na integra:

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property version   "1.00"
05. //+------------------------------------------------------------------+
06. void OnStart()
07. {
08.     long id;
09.     string szSymbol;
10.     int handle;
11.     ENUM_TIMEFRAMES tf;
12.     
13.     Print("Waiting for the chart of the first asset to be opened...");
14.     while (!_StopFlag)
15.     {
16.             while (((id = ChartFirst()) < 0) && (!_StopFlag));
17.             while ((id > 0) && (!_StopFlag))
18.             {
19.                     szSymbol = ChartSymbol(id);
20.                     tf = ChartPeriod(id);
21.                     if ((StringSubstr(szSymbol, 0, 3) == "WDO") && (ChartWindowFind(id, "Stoch(8,3,3)") < 0))
22.                     {
23.                             handle = iStochastic(szSymbol, tf, 8, 3, 3,MODE_SMA, STO_CLOSECLOSE);
24.                             ChartIndicatorAdd(id, (int)ChartGetInteger(id, CHART_WINDOWS_TOTAL), handle);
25.                             IndicatorRelease(handle);
26.                     }
27.                     if (ChartIndicatorName(id, 0, 0) != "MA(9)")
28.                     {
29.                             handle = iMA(szSymbol, tf, 9, 0, MODE_EMA, PRICE_CLOSE);
30.                             ChartIndicatorAdd(id, 0, handle);
31.                             IndicatorRelease(handle);
32.                     }
33.                     id = ChartNext(id);
34.             }
35.             Sleep(250);
36.     }
37.     Print("Service finish...");
38. }
39. //+------------------------------------------------------------------+

Código do Serviço

Note que as mudanças são poucas, mas os resultados são surpreendentes. Aqui vamos usar um ativo presente na B3 ( Bolsa do Brasil ) a fim de executar a demonstração. O ativo em questão é o mini contrato futuro do dólar. Este contrato tem vencimento mês a mês, no entanto isto não nos é problema. Mas para conseguir compreender, vamos a explicação do código em si. Não é algo complexo, mas é preciso ficar atento aos detalhes, caso contrário você irá ficar a ver navios.

Não irei descrever o que já foi visto, então vamos apenas as partes que são novidade. Na linha 19 e 20 capturamos os dados do gráfico que o serviço irá verificar. Precisamos do nome do ativo, assim como do período do gráfico. Mas isto para evitar cometer algum erro depois. Então colocamos estes valores em duas variáveis.

Na linha 21, fazemos duas checagens.

• A primeira é com relação ao nome do ativo que desejamos configurar algo especifico. 
• A segunda é com a presença ou não de um indicador especifico.

Caso ambas checagens sejam verdadeiras, iremos executar as próximas linhas. Agora atenção ao fato de que no nome do ativo, usamos apenas as 3 primeiras letras, isto se deve ao fato de que o ativo é um contrato futuro, e este tem um período de validade. Mas como não queremos ficar a todo momento precisando mudar o nome do ativo. Usamos justamente o que é comum em todas as vezes que o ativo é negociado, independentemente do contrato vigente.

Um segundo ponto de atenção, é com relação ao indicador. Notem que temos que informar o nome curto do mesmo. Caso você não saiba qual é este nome, coloque apenas este indicador no gráfico, e use um script simples para imprimir este nome no terminal. Assim você saberá exatamente qual o nome que deverá ser usado ali. No caso estamos nos referindo ao indicador estocástico de 8 períodos, média de 3, e constante de 3. Mas se o indicador for outro, troque a string para o nome correto. Caso contrário teremos problemas na próxima etapa.

Bem, vamos voltar ao fato de que o indicador não esteja presente no gráfico do ativo especificado. Neste caso iremos primeiramente executar a linha 23, onde configuramos o indicador desejado. Logo depois na linha 24, adicionamos o indicador em uma nova sub janela. Cuidado com este ponto, se você informar um número de sub janela, o MetaTrader 5, irá colocar o indicador na janela indicada. Isto pode acabar gerando uma tremenda de uma confusão. Mas da forma como o código está o MetaTrader 5, irá criar uma nova sub janela e adicionar o indicador nesta sub janela que foi criada.

Já a linha 25, libera o handle. O motivo é que ele não é mais necessário para nós, devendo assim ser liberado. Agora tudo isto que foi descrito a pouco, somente irá acontecer, caso o indicador não esteja presente no gráfico. Se você tentar remover ele, o serviço irá fazer com que o MetaTrader 5 o recoloque no gráfico. Mas se ele estiver presente no gráfico, o serviço irá ficar quieto. Apenas observando o que está acontecendo.

Observação importante: Apesar do código funcionar e ter uma performance adequada, é aconselhável por motivos práticos, mudar o teste visto na linha 27, por algo um pouco melhor. No caso de se usar mais indicadores no mesmo gráfico, o melhor é você testar o nome, e não o index, como está sendo feito no código. Para fazer isto bastaria mudar a linha 27 pelo código mostrado abaixo: 

27.     if (ChartIndicatorGet(id, 0, "MA(9)") == INVALID_HANDLE)

Fazendo isto, não importa o index que o indicador irá ter, apenas um estará presente, e será colocado no gráfico pelo serviço.

Conclusão

Neste artigo, demonstrei algo que poucos realmente sabem como se faz. Se este era o seu caso, me sinto bastante feliz de ter lhe mostrado que o MetaTrader 5 pode ser uma ferramenta muito mais poderosa do que parece. Sendo talvez a melhor plataforma que existe para quem de fato sabe o que está fazendo e consegue explorar as suas capacidades e qualidades.

No vídeo você pode ver como o MetaTrader 5 se comportará ao usarmos o último serviço visto neste artigo. Mas além do que foi mostrado aqui, que é apenas uma introdução ao que realmente iremos precisar fazer. Fico muito feliz pelo fato de que você, caro leitor, ter tido a curiosidade em ler e tentar aprender um pouco mais. No entanto gostaria de ressaltar que o aprendizado é algo que não se dá apenas olhado um artigo, mas sim procurando você mesmo encontrar a solução para os problemas que vão surgindo.

Sempre tente tirar o máximo que for possível de algo. Quando chegar no limite do que era possível, tente procurar pessoas mais qualificadas a ponto de tentar encontrar uma solução, mas sempre tentando superar o que já foi feito antes. Assim as coisas vão evoluindo e você se tornando um verdadeiro profissional.

Vídeo de demonstração.