Simulação de mercado (Parte 06): Transferindo informações do MetraTrader 5 para o Excel

Introdução

Uma das coisas que mais pega e dificulta a vida de algumas pessoas no MetaTrader 5, é o fato de ele não contar com alguns recursos, por assim dizer.

Muita gente, principalmente os não programadores, tem muita dificuldade em conseguir transferir informações entre o MetaTrader 5 e outros programas. Um destes programas é o Excel. Muitos usam o Excel como uma forma de gerenciar e manter o seu controle de risco. Sendo um programa muito bom e fácil de aprender a utilizar. Mesmo para quem não é programador VBA. No entanto, transferir as informações, sejam elas quais forem, entre o MetaTrader 5 e o Excel, não é uma das tarefas mais simples que existe. Principalmente se você não tem conhecimento em programação.

No entanto, é bastante útil que esta comunicação possa existir, pois ela facilita muito a vida geral de quem deseja apenas operar, mas usa o Excel como uma forma de gerenciar o risco que está sendo operado. Mas sem conhecimento adequado, na área de programação você irá com certeza ficar sujeito a programas desconhecidos, ou irá abrir mão de utilizar o MetaTrader 5, pelo simples fato de não conseguir fazer a transferência de informações da plataforma para dentro do Excel.

Felizmente, o Excel conta com algumas formas, bastante interessantes de conseguirmos as coisas. Depois iremos falar delas com mais calma. Mas infelizmente o MetaTrader 5, não conta com nenhum tipo de recurso, que vem como padrão, que nos permite enviar informações para o Excel. Sendo necessário você ter conhecimento de programação, ou adquirir algum tipo de meio a fim de transferir as informações.

Entendendo o problema

Vamos começar, entendendo as primeiras dificuldades envolvidas e meios mais comuns de transferência de dados entre programas e o Excel. Um dos meios mais comuns, é usar o RTD (Real Time Data), ou usar o DDE (Dynamic Data Exchange). No entanto ambas soluções, envolve conhecimento de como programar interface COM (Componet Object Model) e muitos programadores, não tem de fato tal conhecimento. E mesmo que você consiga de fato criar tal coisa, a mesma não é assim tal flexível.

Tanto o RTD quanto o DDE, são forma de comunicação unidirecionais, ou seja eles de fato executam apenas a ponte entre um sistema e outro. Não nos permitindo, algumas coisas que também são bastante interessantes de serem utilizadas, ainda mais se tratando do Excel. Mas pelo fato do Excel, ter suporte nativo a tais sistemas, isto é algo bastante interessante, já que teremos um tipo de comunicação em Real Time.

Mas vamos pensar em termos um pouco mais abrangentes. Quantas vezes você de fato precisa de informações no Excel em Real Time (ou tempo real)? Na maior parte das vezes um breve atraso é perfeitamente aceitável. E aqui não estou falando em pessoas que desejam utilizar o Excel como uma forma de utilizá-lo como um sistema de controle para algum robô operar. Se você está utilizando o MetaTrader 5, irá com toda a certeza, desejar ter os cálculos sendo efetuados dentro da plataforma, não irá querer enviar eles para o Excel. Deixar o Excel calcular a posição, e depois com base nos resultados do Excel, fazer o Expert Advisor tomar uma decisão dentro do MetaTrader 5. Fazer as coisas assim não faz o menor sentido.

No entanto, quem gosta de fazer operações que pode durar 2 ou mais dias. Ou mesmo que gosta de operar Long Short, com toda a certeza irá, e deseja poder contar com o Excel para lhe ajudar, a fim de conseguir gerenciar de forma mais tranquila o capital que está sendo usado. Assim como também tomar decisões relacionadas ao controle de risco. Neste caso você irá, e deseja de fato que o Excel receba as cotações, ou informações de forma automática. Pense só no fato de você estar trabalhando com Long Short, e esteja com 20 posições, neste tipo de modelo. Você teria que atualizar manualmente 40 cotações diariamente, ou de hora em hora, dependendo de como você opera.

O risco de fazer algum tipo de bobagem, e cometer algum erro é enorme. Isto sem contar no tempo que você iria perder para transferir estas 40 cotações, uma a uma. Santa trabalheira.

Assim algumas pessoas, buscam soluções para este tipo de problema. Uma delas é utilizar cotações que vem direto da WEB.

Solução WEB

Esta solução WEB, se baseia em utilizar o próprio Excel para fazer as atualizações para nos. Isto de forma automática. Mas aqui mora um pequeno problema.

Apesar de ser uma solução fácil de ser criada, ela não é de fato adequada. Isto por conta que entre as cotações, existirá um delay, este pode ser maior ou menor. Mas este delay, não é de fato entre as capturas, ele é por que grande parte dos serviços de informação financeira, serem de fato cobrados.

Não existe almoço grátis. Não quando o assunto é ganhar dinheiro. 

Não estou aqui para julgar se é certo ou errado, cobrar por tais serviços. A questão aqui é: Qual o sentido em fazer uso disto, se você tem uma plataforma em suas mãos. No caso o MetaTrader 5.

Quando a pessoa faz uso deste tipo de solução, ela abre no Google a planilha relacionada ao seu e-mail. E e nesta planilha o usuário, digita o seguinte comando:

GoogleFinance

Ao adicionar este comando em uma célula na planilha on-line. Você poderá fazer uma serie de coisas, relacionadas ao ativo que você deseja obter os dados. Todos estes dados serão atualizados de tempos em tempos. Normalmente existe um retardo entre estas atualizações. No caso de você esteja operando uma posição que pode ser modificada apenas e somente depois de alguns dias, tal retardo não é de fato problema. Isto pensando em termos de Buy And Hold, mas se você está fazendo Trade, a coisa pode ser um pouco mais complicada.

Mas voltando a questão principal. Assim que você tiver editado completamente a planilha on-line, você pode salvar a mesma e exportá-la para ser utilizada em outro local. A exportação não irá de fato ser uma exportação real. Tudo que você deseja de fato é obter os valores que a função GoogleFinance está capturando, e levar tais valores para uma outra planilha, esta no seu terminal, para poder trabalhar mais tranquilamente.

Apesar desta solução funcionar para grande parte dos casos, ela não é adequada a outros casos. Em diversos casos, de fato precisamos da cotação, e normalmente apenas da cotação, mas com um mínimo de retardo. No entanto, independente do que se faça, você não conseguirá uma velocidade de atualização inferior a 1 minuto usando tal solução. Isto pode ser visto na imagem 01.

Imagem 01 - Janela de propriedades

Nesta imagem 01, vemos a janela de propriedades, que ajusta a temporização de atualização, do componente que está sendo importado pelo Excel. Se você não sabe, ou nunca viu esta janela, não se preocupe. Irei mostrar como você faz para chegar neste ponto. Mas observem o seguinte: Mesmo que você coloque o tempo mínimo de 1 minuto aqui. Não significa que de fato a cotação utilizada está com um delay de 1 minuto entre elas, já que a função GoogleFinance, não é de fato atualizada nesta velocidade.

Então é bom você estar consciente do que estamos fazendo aqui. Estou apresentando uma forma de você ter a cotação do ativo em um tempo que terá um retardo de 1 minuto. Se a sua intenção é ter uma cotação em tempo real, a cada variação do preço, terá que usar uma abordagem diferente da que irei apresentar. Mas a que será vista aqui, dará conta do recado em grande parte das vezes. Sendo muito boa para uma vasta gama de problemas. Isto por que você irá notar que a programação necessária é muito simples de ser entendida, além de termos uma forma bastante eficaz de comunicação entre o MetaTrader 5 e o Excel.

Compreendendo a implementação

Existem algumas soluções bem mais complexas, envolvendo Python a fim de conseguir uma cotação em tempo real. E outras mais simples que envolvem o uso do RTD ou DDE. Mas está daqui, você poderá criar diretamente em MQL5, sendo fácil e rápido de implementar, mas ao mesmo tempo, elegante e agradável de ser utilizada.

A primeira coisa que você precisa entender, é que existem 4 formas básicas de aplicação para o MetaTrader 5. Cada uma é adequada para uma determinada coisa.

• Expert Advisor - Os famosos EA, ou robôs, são aplicações do MetaTrader 5, que nos permite enviar ordens ou pedidos de negociação para que o servidor presente na Bolsa. Tais programas são basicamente voltados para este tipo de tarefa.
• Indicadores - Estes nos permite adicionar, ou mostrar algo no gráfico. Servem para diversas coisa envolvendo monitoramento do preço a fim de nos mostrar algo especifico para o qual ele foi programado.
• Script - Estes nos permite fazer algum tipo de tarefa, Normalmente scripts entram e saem muito rapidamente do gráfico, não permanecendo ali por muito tempo. Mas eles estão sempre atrelados a um gráfico especifico.
• Serviços - Assim como os scripts. Serviços normalmente executam algum tipo de tarefa especifica, entrando e saído rapidamente. Mas diferente do scripts, os serviços não estão atrelados a nenhum gráfico especifico. Permanecendo ativos mesmo quando não existe nenhum gráfico no terminal MetaTrader 5.

Como você deve ter notado. Todas as aplicações possíveis no MetaTrader 5, tem a sua utilidade. Mas apenas e somente os serviços, independem da existência de algum gráfico presente e aberto na plataforma. Sendo assim a melhor das soluções.

Nota: Apesar de Serviços e Scripts terem um comportamento diferente, devido ao fato de que os scripts estão atrelados a um gráfico. Em termos de código, tanto o serviço quanto um script, são praticamente idênticos. Sendo que a única coisa que os diferencia é o fato de que um serviço tem em seu código a seguinte propriedade ativada:

#property service

O simples fato de que esta linha acima esteja presente no código do script, faz com que ele deixe de ser um script, e se torne um serviço.

Então a solução que iremos utilizar, será a criação de um serviço, mas como acabei de informar, você pode usá-lo também como um script. Mas neste caso ele estará atrelado a um gráfico. No entanto, a única real mudança que será preciso ser feita no código, e a remoção da propriedade vista acima. Mas iremos voltar a isto em breve, quando formos ver o código em si.

Começando a implementar a solução

Já que alguns que podem estar lendo este artigo. Talvez não tenham muito conhecimento sobre Excel, vou mostrar como fazer as coisas nele, pelo menos o básico. Se este não é o seu caso, pode ir para o próximo tópico, onde irei mostrar como implementar o serviço no MQL5, a fim de usar ele no MetaTrader 5 e ter os dados que você deseja diretamente no Excel.

Antes de fazer qualquer coisa você deverá editar um pequeno arquivo, este será usado depois pelo MetaTrader 5. Mas você não pode colocar este arquivo em qualquer local. Por motivos de segurança, o MQL5, não permite você usar qualquer ponto no sistema de arquivos presentes no seu computador. Então para fazer as coisas de maneira correta, você precisará abrir o MetaEditor e na aba de navegação, fazer o que está sendo mostrado na animação 01 logo abaixo:

Animação 01 - Acessando o diretório correto

Ao fazer isto, o explorador de arquivos do sistema operacional irá ser aberto, e você irá se encontrar na pasta FILES, dentro do diretório do MQL5. O arquivo que deverá ser criado, deverá estar, inicialmente, nesta pasta. Então nesta pasta, você deverá construir o seguinte arquivo, mostrado abaixo. Isto apenas para exemplificar, o que iremos de fato fazer.

PETR4;
VALE3;
ITUB3;

Salve este arquivo com o nome de QUOTE.CSV. Mas não feche por enquanto o explorador de arquivos. Iremos precisar dele na próxima etapa, isto para facilitar o encontrar este arquivo que acabamos de salvar.

Agora abra o Excel, com uma folha em branco. e siga a seguinte sequência, a fim de ligar este arquivo QUOTE.CSV ao planilha que estamos criando no Excel.

Figura 02

Nesta figura 02, mostra onde está o que iremos precisar acessar, caso não esteja presente no Excel esta opção, procure ela em Get Data. Mas de qualquer forma, você deverá selecionar que iremos puxar dados de um arquivo de texto. Seria quase da mesma forma de puxar dados da WEB, mas aqui iremos usar um arquivo.

Figura 03

Depois que você usar a opção mostrada na figura 02, irá se abrir uma janela de pesquisa. Navegue nela até o local indicado no explorador de arquivos de modo a chegar no arquivo QUOTE.CSV, que estará salvo no diretório do MQL5. Quando o encontrar aceite ele, e você irá ver o conteúdo mostrado na figura 03. Observem as configurações de carregamento do arquivo, mostradas no alto da figura 03. Se tudo estiver correto clique na setinha que está ao lado do botão Load e selecione Load To... Você será direcionado para a figura 04.

Figura 04

Nesta figura 04, você pode selecionar onde os dados serão lançados na planilha. No caso, e já que é apenas para demonstração, deixe como indicado na região em destaque. Logo depois clique no botão Ok e você terá como resultado o que pode ser visto na figura 05.

Figura 05

Ok. Os dados estão carregados. Mas ainda falta uma coisa. Dizer ao Excel como, e quando, eles deverão ser atualizados. Lembre-se não estamos usando um servidor RTD ou DDE. Então é preciso dizer ao Excel quando atualizar estes dados, caso contrário eles jamais serão atualizados. Se você tiver conhecimento suficiente em VBA poderá desenvolver algo melhor. Mas aqui estou querendo deixar as coisas, de maneira que seja simples, e qualquer um consiga fazer o que é pretendido. Então para que o Excel saiba como e quando atualizar os dados presentes no arquivo QUOTE.CSV, você irá precisar acessar o que é mostrado na figura 06.

Figura 06

Ao selecionar a tabela no Excel, a aba Query irá se tornar ativa. Nesta aba selecione o elemento Properties como mostrado acima. Quando você clicar neste elemento, irá ver inicialmente, exatamente a figura 07.

Figura 07

Observem com atenção esta figura 07. Nesta janela você deverá modificar algumas coisas. Assim o Excel será capaz de atualizar automaticamente os dados para nos. Mas reparem o fato de que o objeto que será atualizado é somente a tabela que acabamos de construir com base nos dados vindos do arquivo QUOTE.CSV. Então mude a figura 07 de modo a ela ficar como mostrado na figura 08.

Figura 08

Assim que você confirmar as alterações, clicando em OK, o Excel passará a seguir as configurações definidas. Assim a cada, aproximadamente 60 segundos ele irá atualizar os dados da planilha conforme eles vão sendo modificados no arquivo. Experimente fazer isto. Abra o arquivo em um Editor de textos e adicione um valor ali, mais ou menos como mostrado abaixo:

PETR4;30.80
VALE3;190.31
ITUB3;25.89

Salve o arquivo QUOTE.CSV, mas não precisa fechar o Editor de textos. Aguarde um tempo, o olhe o resultado no Excel. Quase como mágica, você irá ver a planilha ser atualizada para o que pode ser visto na figura 09.

Figura 09

Mude novamente os valores usando o editor de texto, até compreender o que está acontecendo. Vejam que podemos fazer bastante coisa a partir deste momento. Isto sem precisar recorrer a algum tipo de solução maluca ou complicada. Uma outra coisa que talvez seja interessante mencionar, é o fato de que você pode usar um compartilhamento local. Assim o Excel pode ser executado em um terminal diferente do MetaTrader 5. Não precisando necessariamente estar na mesma máquina.

Implementando o serviço em MQL5

Na explicação que foi dada no tópico anterior, mencionei o uso de um arquivo, e onde você precisa coloca-lo. Mas agora para terminar de fato este artigo, precisamos criar o serviço que será executado no MetaTrader 5. Porém não se preocupem, a coisa aqui será muito simples de ser criada e utilizada. Tanto que no final deste artigo, você poderá ver um vídeo de demonstração, a fim de esclarecer qualquer tipo de dúvida sobre o modo de operar o sistema.

Antes de mais nada, devo dizer que diferente do que aparece no vídeo de demonstração. Você não precisa de fato ter os ativos presentes na janela de observação de mercado. Ali no vídeo, os ativos estão presentes, para que você possa acompanhar e ver como o processo se dá, mas em uma execução típica, tal coisa não é de fato exigida. Podendo apenas o serviço ser executado, e este nada irá interferir nos ativos presentes na observação de mercado, ou na performance do MetaTrader 5.

Muito bem, partindo do fato de que você criou o arquivo que precisamos e foi mostrado no tópico anterior. Podemos ir, para o código do serviço, e desta forma, entender como a coisa toda irá de fato funcionar. O código do serviço pode ser visto na integra logo abaixo:

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property description "Quote sharing service between"
05. #property description "MetaTrader 5 and Excel"
06. #property version   "1.00"
07. //+------------------------------------------------------------------+
08. input string user01 = "Quote.csv"; //FileName
09. //+------------------------------------------------------------------+
10. class C_ShareAtExcel
11. {
12.     private :
13.             string  szSymbol[],
14.                     szFileName;
15.             int     maxBuff;
16.             bool    bError;
17. //+------------------------------------------------------------------+
18. inline void Message(const string szMsg)
19.                     {
20.                             PrintFormat("Sharing service with Excel: [%s].", szMsg);
21.                     }
22. //+------------------------------------------------------------------+
23.     public  :
24. //+------------------------------------------------------------------+
25.             C_ShareAtExcel(string szArg)
26.                     :bError(true),
27.                      maxBuff(0),
28.                      szFileName(szArg)
29.                     {
30.                             int     file;
31.                             string  sz0, szRet[];
32.     
33.                             if ((file = FileOpen(szFileName, FILE_CSV | FILE_READ | FILE_ANSI)) == INVALID_HANDLE)
34.                             {
35.                                     Message("Failed");
36.                                     return;
37.                             }
38.                             while (!FileIsEnding(file))
39.                             {
40.                                     sz0 = FileReadString(file);
41.                                     if (StringSplit(sz0, ';', szRet) > 1)
42.                                     {
43.                                             ArrayResize(szSymbol, maxBuff + 1);
44.                                             szSymbol[maxBuff] = szRet[0];
45.                                             StringToUpper(szSymbol[maxBuff]);
46.                                             maxBuff++;
47.                                     }
48.                             }
49.                             FileClose(file);
50.                             bError = false;
51.                             Message("Started");
52.                     }
53. //+------------------------------------------------------------------+
54.             ~C_ShareAtExcel()
55.                     {
56.                             ArrayResize(szSymbol, 0);
57.                             Message("Finished");
58.                     }
59. //+------------------------------------------------------------------+
60.             void Looping(int seconds)
61.                     {
62.                             string  szInfo;
63.                             int     file;
64.                             
65.                             while ((!_StopFlag) && (!bError))
66.                             {
67.                                     szInfo = "";
68.                                     for (int c0 = 0; c0 < maxBuff; c0++)
69.                                             szInfo += StringFormat("%s;%0.2f\r\n", szSymbol[c0], iClose(szSymbol[c0], PERIOD_D1, 0));
70.                                     if ((file = FileOpen(szFileName, FILE_TXT | FILE_WRITE | FILE_ANSI | FILE_SHARE_WRITE)) != INVALID_HANDLE)
71.                                     {
72.                                             FileWriteString(file, szInfo);
73.                                             FileClose(file);
74.                                     };
75.                                     Sleep(seconds * 1000);
76.                             }
77.                     }
78. //+------------------------------------------------------------------+
79. };
80. //+------------------------------------------------------------------+
81. C_ShareAtExcel *share;
82. //+------------------------------------------------------------------+
83. void OnStart()
84. {
85.     share = new C_ShareAtExcel(user01);
86.     
87.     share.Looping(2);
88.     
89.     delete share;
90. }
91. //+------------------------------------------------------------------+

Código fonte do Serviço

Como você pode ver, o código é extremamente compacto. Mas como é de meu costume, aqui fazemos uso de uma classe, isto para que em caso de decisão futura, eu consiga utilizar o código em algum outro tipo de coisa. Mas nada impede, de você criar este mesmo código, como sendo um único procedimento. Sendo que todo ele estaria presente na função OnStart.

Mas vamos aos detalhes e a explicação de funcionamento do código. Assim mesmo que você esteja iniciando no MQL5, irá conseguir adaptar ele a fim de repassar outras informações para o Excel.Nota: Estou tratando aqui do Excel, mas nada impede de você transferir dados para outros programas, ou sistema.

Na linha 2 temos a indicação de propriedade do código. Isto irá informar ao MQL5, que o código deverá ser tratado como sendo um serviço. Caso você deseje utilizá-lo como sendo um script, desabilite ou remova esta linha 2. O fato de fazer isto não irá influenciar em nada no trabalho, ou execução do código. Apenas irá fazer com que ele seja atrelado a um gráfico, a fim de que possa funcionar.

Na linha 8 damos ao usuário a possibilidade de informar qual será o arquivo a ser usado. Lembrando que o arquivo deverá ser editado e criado como foi informado no tópico anterior, caso contrário, o sistema não irá funcionar.

Na linha 10 iniciamos a criação da nossa classe. Atenção ao fato de que na linha 12 temos a declaração de uma clausula privativa, ou seja tudo que vier a partir deste ponto será privativo a classe, não podendo ser acessado fora da mesma. Então declaramos algumas variáveis globais para a classe, e logo depois na linha 18, criamos um procedimento a fim de padronizar as mensagens a serem impressas no terminal. Estas servem para dizer o que o serviço está fazendo.

Na linha 24, declaramos uma clausula publica, então deste ponto em diante, tudo que estiver presente na classe, poderá ser acessado, como se fizesse parte da classe. Imediatamente na linha 26, começando a criação de um constructor da classe. Este irá receber como argumento o nome do arquivo que iremos usar. Reparem que a programação é feita, pensando no fato da classe não fazer parte do código do serviço. Esta é a forma correta de se trabalhar com programação orientada a objetos (OOP), mesmo que tenhamos a informação, que está presente na linha 8, devemos pensar que não a temos. E que a mesma será repassada depois.

Aqui na linha 33, iremos tentar abrir o arquivo indicado. Caso não tenhamos sucesso na tentativa de abrir o arquivo para leitura. Iremos informar isto usando a linha 35, e o código irá retornar na linha 36. No entanto, supondo que o arquivo possa ser acessado, iremos começar a ler o mesmo. A leitura irá se dar linha a linha, e para fazer isto iremos usar o laço que se inicia na linha 38. Na linha 40, fazemos a leitura de uma linha completa presente no arquivo indicado. Já na linha 41, iremos isolar o código do ativo, de qualquer outro tipo de informação presente ali na linha. Observem que fazemos uso do separador ponto-virgula (;).

Se esta linha 41 indicar que o sistema é válido, iremos alocar uma nova posição na memória, e armazenar o código do ativo nesta posição. Atenção ao fato de que o código não precisa estar em caixa alta, isto por conta que na linha 45, ajustamos as coisas. Mas notem também que não existe nenhuma checagem, a ponto de verificar se o ativo de fato existe. Ou seja você precisa informar o código de um ativo válido. Mas este tipo de verificação não é de todo necessário aqui. Estou dizendo da checagem de código do ativo, já que quando os dados forem lançados no Excel, você logo irá notar algo estranho. E com isto providenciando a correção. Por conta disto não se faz necessário verificar o código do ativo aqui no MQL5.

Se tudo ocorrer bem, iremos fechar o arquivo, e informar no terminal que o serviço está ativo. Isto usando a linha 51.

A próxima coisa que vemos no código, é o destructor da classe, este tem seu código iniciado na linha 54. Contando, com tão somente duas linhas, este destructor, irá devolver a memória alocada e informar que o a classe está sendo retirada da lista de tarefas do sistema.

Agora na linha 60, contamos com o procedimento principal da nossa rotina. Este procedimento irá fazer com que a classe, fique em loop, até que o serviço, no caso, seja encerrado. Este loop se inicia na linha 65. Agora atenção, este loop não acontece de maneira a gerar uma sobre carga ao processador, ou a plataforma. Entre uma execução e outra, damos um prazo para que outras coisas sejam executadas. Este prazo é dado em segundos, sendo informado como argumento da chamada. Tal argumento é usado na linha 75, onde a pausa acontece, antes do próximo loop ser executado.

Agora vem onde a mágica acontece, dentro deste loop. Na linha 67, limpamos o conteúdo da string que será gravada no arquivo. Então para que a gravação aconteça de forma o mais rápida possível, já que podemos estar gravando no exato momento em que o Excel está lendo os dados, e sim isto pode acontecer, efetuamos um laço na linha 68. Este laço irá montar na linha 69, os dados que será lançados para o Excel. Neste ponto você pode colocar qualquer coisa. Literalmente qualquer coisa mesmo.

Assim que o laço na linha 68 finalizar, iremos tentar acessar o arquivo na linha 70. Atenção: Normalmente esta tentativa de escrever em um arquivo, ao mesmo tempo que outra aplicação tenta ler o mesmo arquivo gera erros de acesso. Alguns destes erros podem promover falhas na transferência de dados. Este tipo de falha é muito bem estudada quando se trabalha com algoritmos do tipo Produtor Consumidor. Mas aqui e felizmente o MQL5, nos dá a possibilidade de usar um sinalizador FILE_SHARE_WRITE, este informa ao sistema, que pode acontecer de estarmos acessando um arquivo ao mesmo tempo que outra aplicação também esta fazendo isto.

Caso tenhamos sucesso em poder escrever no arquivo, este será escrito em uma única chamada. Isto na linha 72, logo depois e imediatamente na linha 73, fechamos o arquivo.

Assim o ciclo se fecha, e ficamos nesta durante todo o tempo.

Conclusão

Neste artigo, você aprendeu como transferir dados do MetaTrader 5 para o Excel de uma forma super simples e bastante interessante. Sendo uma forma ideal para quem deseja fazer acompanhamento de carteira, ou de operações que não precisam de atualização em Real Time.

No vídeo abaixo, você pode verificar como o sistema funciona e tirar alguma dúvida, que possa aparecer por conta de algum detalhe referente as questões envolvendo o uso de valores financeiros. Já que o sistema é muito simples, e toda a explicação presente no artigo é mais que suficiente para que qualquer um consiga usar o código, não haverá nenhum anexo, mesmo por que tudo irá ser totalmente dependente dos ativos que você irá de fato acompanhar.