Do básico ao intermediário: SandBox e o MetaTrader

Introdução

No artigo anterior Do básico ao intermediário: Eventos em Objetos (IV), foi explicado e demonstrado, como você, meu caro leitor, poderia vir a desenvolver uma metodologia a fim de conseguir redimensionar diretamente no gráfico, alguns objetos que ali existissem. Como o objetivo aqui, NÃO É o desenvolvimento de nenhuma aplicação, mas sim a demonstração a fim de exemplificar como você usando o MQL5, pode controlar e manipular as coisas no MetaTrader 5. Não vejo neste momento motivos para nos profundarmos ainda mais no que foi visto ali naquele artigo.

Apesar de que, poderíamos incrementar e muito aquele tipo de implementação a fim de conseguir fazer ainda mais coisas. Porém meu interesse e objetivo aqui é outro. Assim, vamos começar a explorar um outro tipo de tópico, que também é muito importante que você venha a entender os conceitos antes de começar a querer se aventurar em outros tipos de atividades relacionadas a programação.

Como de costume, vamos iniciar um novo tópico, para começar a falar do que será o tema, desde e dos próximos artigos.

Trabalhando com arquivos

Um dos temas, que pode vir a se tornar extremamente avançado, dependendo do que você esteja querendo fazer. É justamente o fato de precisar trabalhar com arquivos. Apesar de muitos considerarem este tema, algo simples e até mesmo banal. Dado o tipo de coisa que muitos costumam fazer ou ver sendo feito. A realidade é bem diferente, do que possa parecer.

Trabalhar com arquivos, é de longe um dos temas mais complexos e difíceis de ser dominado. Isto pelo simples fato, de que, um arquivo, pode conter qualquer coisa. E isto literalmente. O fato de que muita gente, acredita ser simples mexer e manipular arquivos, se deve justamente ao fato, de que na maior parte das vezes o conteúdo representado ali, ser algo muito fácil de entender. Justamente por conta do tipo de informação presente ali.

No entanto, devido ao fato de que arquivos, poderem conter, informações binárias, podendo estas serem desde valores numéricos ou de configurações de uma aplicação. Até mesmo a própria aplicação em si, seja em forma de código objeto, ou em grande parte dos casos, opcodes de instrução de máquina. Não é de se admirar que este tema acaba por ficar extremamente complexo e de maneira muito rápida. Isto justamente devido ao próprio formato que o arquivo passa a conter internamente.

Porém, para que todos consigam entender, acompanhar e perceberem o que e como podemos fazer. Iremos começar devagar. Com algum modelo mais simples, e isto a princípio. De forma, que conforme você for assimilando e captando os conceitos, poderemos entrar em temas ainda mais elaborados e complexos. Mas sempre tentando manter uma boa didática a respeito do assunto.

Para começar, precisamos entender uma coisa a respeito do próprio MetaTrader 5 e como ele lida com arquivos. E sim, existe diferenças entre usar o MetaTrader 5, programando tudo via MQL5 puro e usar o MetaTrader 5, programando parte das coisas fora do MQL5. E você precisa entender isto, antes de começarmos de fato a mexer com arquivos.

Quando você usa MQL5 puro, a fim de programar algo para controlar ou manipular o MetaTrader 5, você fica restrito ao que é conhecido como caixa de areia, ou SandBox. Este termo SandBox, é muito usado atualmente, graças aos sistemas operacionais modernos, que permitem criar uma condição para executarmos aplicações desconhecidas de forma um pouco mais segura. Isto por que, a aplicação terá a impressão de poder fazer qualquer coisa. Porém, toda e qualquer mudança feita irá ser destruída assim que a SandBox, onde a aplicação foi executada for destruída.

Isto garante que, mesmo uma aplicação potencialmente danosa, não danifique nenhum arquivo, ou venha a contaminar o sistema operacional, com algum tipo de falha. Ou seja, uma SandBox seria como uma região segura, onde nada que esteja fora dela, será afetada.

Pois bem, o MetaTrader 5, trabalha com algo parecido. Sendo que temos uma SandBox padrão, quando usamos o MQL5 puro. Porém caso venhamos a usar uma programação externa, ou mesmo alguma DLL, podemos fazer com que esta SandBox do MetaTrader 5 venha a ser rompida. Permitindo assim que acessemos regiões de disco, ou do sistema de arquivos, fora da SandBox do MetaTrader 5. Mas espere um pouco, isto não seria algo bom? Já que poderíamos gravar dados em dispositivos, ou em alguma parte do sistema de arquivos que não teríamos acesso naturalmente?

Bem, esta é uma questão um tanto quanto complicada de ser explicada neste momento, meu caro leitor. Existem vantagens e desvantagens em se acessar algo fora da SandBox. Porém, a princípio, você deve entender que isto é mais perigoso do que realmente vantajoso. Já que se alguma aplicação sendo executada no MetaTrader 5, vier a ter acesso fora da SandBox, ela poderá vir a ter acesso a algo que não deveria. E isto em muitos casos pode ser um risco a integridade de todos os seus arquivos.

Pense no fato de que, você estará executando uma aplicação para trabalhar com dinheiro. E sem o devido cuidado, você pode vir a executar uma aplicação no MetaTrader 5, que acabará tendo acesso a alguns dos seus arquivos, que a princípio a aplicação não teria acesso. Justamente por conta da questão da SandBox. Porém para que isto ocorra de fato, você, como usuário, precisa dar permissão para que a aplicação venha a poder fazer isto.

Normalmente isto acontece, quando você habilita o que é mostrado na imagem logo abaixo.

Imagem 01

Nesta imagem 01, temos o ponto chave que pode vir a permitir que uma aplicação, sendo executada no MetaTrader 5, saia da SandBox. Tanto que existe a aviso de que isto pode ser danoso ao sistema, caso esta opção venha a ser habilitada. Isto devido justamente a questão envolvida na manipulação de arquivos, sem o devido conhecimento pelo MetaTrader 5. Já que uma vez fora da SandBox, o MetaTrader 5, não terá mais nenhum controle sobre o que estará ocorrendo. Passando este controle ser feito, pela aplicação e possíveis chamadas as DLLs do sistema operacional. Mesmo que pareça seguro, uma aplicação maliciosa, pode usar as DLL presentes no próprio sistema operacional para promover danos catastróficos. ENTÃO CUIDADO.

Ok, mas então como a SandBox iria nos proteger nestes casos? Bem, esta é a parte realmente interessante, meu caro leitor. Isto por que, os desenvolvedores do MetaTrader 5, foram bastante astutos em separar as coisas em pequenos blocos. Onde cada bloco poderia ser pensado, como a representação de uma SandBox, totalmente isolada uma da outra. Se bem que não é bem assim na prática. Mas isto você irá entender, com o decorrer do tempo, e conforme for praticando o que será mostrado e explicado.

Neste início, iremos basicamente, trabalhar dentro da SandBox de forma o mais simples possível e sem muita complicação. Isto de forma que você poderá tanto criar, quanto também manipular arquivos e diretórios sem muito stress ou risco de perda de dados. Já que a SandBox foi pensada para servir para isto mesmo.

Muito bem, então vamos começar com algo bem simples e fácil de entender. Isto é feito fazendo uso do código logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const string szText = "This file was created by a script written in MQL5.";
07.     uchar info[];
08. 
09.     StringToCharArray(szText, info);
10. 
11.     FileSave("Hello.txt", info);
12. }
13. //+------------------------------------------------------------------+

Código 01

Este é um código de escrita de arquivo muito simples e fácil de entender. Porém, existe uma coisa que acontece quando você executar este código, que pode lhe deixar um pouco intrigado. Mas vamos por partes. Primeiro na linha seis deste código 01, temos uma mensagem que será colocada em um arquivo. Mas qual arquivo? Bem, o nome do arquivo está sendo indicado na linha onze. Ok, mas onde este arquivo será salvo? Ou melhor dizendo, em que diretório presente no disco, que eu deverei procurar ou esperar que este arquivo venha a ser salvo? Bem, isto depende de algumas condições, meu caro leitor. Da forma como o código está sendo mostrado ele será salvo dentro do diretório padrão da SandBox do MetaTrader 5.

A posição exata, dentro da arvore de diretório, irá depender se você está executando o código dentro do MetaTrader 5, ou de um agente de teste. De qualquer maneira, vamos considerar que você de fato venha a executar todos os códigos diretamente no MetaTrader 5. Neste caso o arquivo será gravado na subpasta MQL5\Files. Isto pode ser visto logo abaixo, na imagem vista na sequência.

Imagem 02

Agora, nesta mesma imagem 02, você pode observar que está sendo apontada por uma seta um caractere estranho. Este caractere de fato faz parte do arquivo, tendo sido salvo nele. Porém, olhando a mensagem na linha seis, não vemos nenhum indicio da presença deste caractere. Então de onde ele veio? Bem, meu caro leitor, este caractere surgiu devido a linha nove. Como estamos transformando uma string em um array de caracteres, isto para que a função da linha onze pudesse de fato gravar a string no arquivo. O caractere de fim da string também irá fazer parte do conteúdo a ser salvo. Visto que ele não foi removido da string convertida em um array.

Certo, mas isto seria algum problema? A princípio este fato não representaria nenhum tipo de problema, meu caro leitor. Desde que você esteja ciente de que isto estará acontecendo. Mas como este código 01 é muito simples e voltado para que tenhamos o primeiro contato com o sistema de arquivo. Não vejo motivos para preocupações neste exato momento.

Ok, para demonstrar que a princípio este conteúdo visto na imagem 02, com este caractere, aparentemente estranho, presente no arquivo. Não representa um problema para nós. Isto neste momento. Vamos modificar o código 01, de forma que possamos ler o arquivo que foi gravado, e logo depois imprimir o conteúdo no terminal. Isto pode ser visto no código 02, logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06. #define szFileName "Hello.txt"
07. 
08.     const string szText = "This file was created by a script written in MQL5.";
09. 
10.     uchar W[], R[];
11. 
12.     StringToCharArray(szText, W);
13. 
14.     FileSave(szFileName, W);
15. 
16.     FileLoad(szFileName, R);
17. 
18.     Print(CharArrayToString(R));
19. }
20. //+------------------------------------------------------------------+

Código 02

Legal, para que possamos garantir que estaremos lendo o mesmo arquivo, que estaremos gravando. Usamos a definição da linha seis neste código 02, a fim de indicar o nome do arquivo que estará sendo usado. Como as primeiras linhas já foram explicadas antes, podemos partir para a linha 16. Aqui estaremos lendo o conteúdo do arquivo e o colocando em um array. Já na linha 18 iremos transformar este array de caracteres em uma string, devendo assim permitir que possamos imprimir a mesma mensagem vista na linha oito.

Para comprovar isto, quando o código 02 é executado, podemos ver o resultado logo na imagem abaixo.

Imagem 03

Ou seja, de fato funcionou como esperado. Sendo este o princípio mais simples de todos. Onde com apenas muito pouco código, conseguimos armazenar e depois ler o conteúdo de um arquivo. Sem muito stress, ou complicação.

Mas vamos complicar as coisas só um pouco, para que você de fato comece a entender certos detalhes sobre esta questão de ler e escrever arquivo. Para começar, vamos mudar a SandBox. Para fazer isto, tudo que precisamos fazer, será modificar o código mostrado até aqui para o código visto logo na sequência.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06. #define szFileName "Hello.txt"
07. 
08.     const string szText = "This file was created by a script written in MQL5.";
09. 
10.     uchar W[], R[];
11. 
12.     StringToCharArray(szText, W);
13. 
14.     FileSave(szFileName, W, FILE_COMMON);
15. 
16.     FileLoad(szFileName, R, FILE_COMMON);
17. 
18.     Print(CharArrayToString(R));
19. }
20. //+------------------------------------------------------------------+

Código 03

Ao executar este código 03, você irá ver o mesmo resultado visto na imagem 03. Porém se você for procurar o arquivo, irá notar que ele não está sendo criado na subpasta MQL5\Files. Ele estará sendo criado em outro local. Mas onde? Bem, antes de falarmos sobre isto, note que a única diferença entre o código 02 e este código 03. É justamente um parâmetro extra que foi adicionado nas linhas 14 e 16 e que podem ser vistos neste código 03.

Agora preste muita atenção meu caro leitor. Quando o arquivo está sendo gravado na linha 14, este parâmetro extra estará dizendo o MetaTrader 5, onde será a SandBox a ser utilizado pelo arquivo. Porém se durante a leitura, que é feita na linha 16, este mesmo parâmetro não for informado. O MetaTrader 5, irá procurar o arquivo na SandBox padrão. Ou seja, na subpasta MQL5\Files. E com isto, poderá vir a nos dar um resultado diferente do esperado. Podendo ser um erro na leitura ou acesso ao arquivo, ou em alguns casos, um conteúdo completamente estranho. Muito diferente do que estimávamos encontrar.

Então para que tudo funcione de maneira adequada, tanto a leitura, quanto a gravação, deve estar em comum acordo com relação ao local onde o arquivo deva estar. Nada adianta você indicar uma SandBox, durante a gravação e indicar outra para a leitura, ou vice versa. Esperamos que o MetaTrader 5, venha a entender o que você estará tendo de fazer, ou que arquivo você esteja tentando acessar. Pois ele não tem esta obrigação e tão pouco interesse em tentar fazer isto.

Apesar de em alguns tipos de cenários, ele de fato possa a vir a conseguir encontrar o arquivo correto. Mas não conte com isto. Pois fatalmente, você poderá estar escrevendo ou lendo no lugar errado. O que pode acabar destruindo tanto a sua expectativa de encontrar certo tipo de informação, como também qualquer informação que existisse em um arquivo, que por conta de uma falha sua, foi sobre gravado com novas informações.

Ok, agora podemos então tentar entender para onde este parâmetro extra, visto nas linhas 14 e 16 do código 03, está fazendo o MetaTrader 5 apontar a SandBox. Isto a fim de que você possa encontrar o arquivo por meio de algum outro editor, caso queira fazer isto. Este parâmetro FILE_COMMON, diz ao MetaTrader 5, para utilizar a subpasta \Terminal\Common\Files, simples assim. Mas espere um pouco, deixe-me ver ser entendi o que está acontecendo aqui. Quando o parâmetro FILE_COMMON não está presente estaremos apontando para o que seria a SandBox MQL5\Files e quando ele está presente estaremos apontando para a SandBox \Terminal\Common\Files. É isto? Sim, meu caro leitor, é isto mesmo que estará acontecendo. Mas eu imaginei que deveríamos indicar o diretório, para que esta mudança ocorresse. De certa maneira isto me parece um pouco confuso.

Na verdade, não é tão confuso assim, meu caro leitor. Talvez você esteja achando isto confuso justamente por ainda não entender o conceito de SandBox. Mas vamos com calma para que você consiga entender este conceito, de forma a poder fazer uso dele nas mais diversas situações. Pois entender de maneira adequada este conceito é muito importante para que você consiga usufruir do MetaTrader 5 em uma faixa maior de possibilidades.

Entendendo a SandBox

Para que você entenda de forma adequada o conceito de SandBox, ou caixa de areia. Será necessário que você tenha algum conhecimento sobre como um sistema de arquivos funciona. Vou dar uma rápida explicação, apenas para que alguns termos que serão utilizados na explicação, possam vir a fazer sentido. Isto para aqueles que os desconhecem.

O primeiro termo a ser entendido é o conceito de raiz. Uma raiz seria como um ponto inicial em uma arvore de diretórios. A ideia de arvore, vem do fato de que cada galho ou ramo de uma arvore, seria o equivalente a uma subpasta dentro de um mesmo diretório. E cada folha, em um destes ramos ou galhos, seria o equivalente a um arquivo. Então simplificando: Uma raiz seria o diretório inicial. Sendo que cada arvore de diretórios, teria apenas e somente uma única raiz. Com base nesta raiz, temos inicialmente um ramo, ou galho. Qualquer folha que esteja neste galho, ou ramo, seria um arquivo que estaria ligado diretamente a raiz. E uma arvore NÃO tem contato direto com outra arvore. Ou seja, NÃO existe uma arvore com duas raízes distintas. E todas estão ligadas a terra.

Entendido isto, podemos começar a fazer uma analogia visual, com o que seria a SandBox presente no MetaTrader 5. Isto é feito na imagem logo abaixo.

Imagem 04

Esta imagem 04 representa duas SandBox, que foram exatamente as que usamos no tópico anterior. Observem que a base inicial é a subpasta MetaQuotes\Terminal. Porém está NÃO É A RAIZ, mas sim o substrato, onde as árvores se encontram alojadas.

Agora note o seguinte: A árvore #1 tem uma raiz, que no caso estaria em Common\Files. Já a árvore #2 tem outra raiz que estaria em MQL5\Files. Observem que não podemos sair de uma árvore diretamente para outra. Não sem antes passarmos pelo que seria o substrato. Normalmente para se fazer isto, que seria sair de um dos ramos para outro ramo usaríamos um artificio. Porém aqui este mesmo artificio não poderia ser utilizado. Já que uma árvore seria como uma SandBox, enquanto a outra árvore seria outra SandBox.

Para tornar isto um pouco mais palatável e ao mesmo tempo, permitir que você estude e tente entender como as coisas poderiam ser feitas. Vamos modificar o código visto no tópico anterior, para podermos adicionar diretórios em nosso ramo de pesquisa. Fazer isto é algo bem simples e direto. Mas os resultados, são realmente muito interessantes. Podendo assim tornar mais simples de você entender como a SandBox trabalha na prática. Isto a fim de garantir que tudo fique dentro do controle. Logo abaixo podemos ver o código que iremos usar inicialmente.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06. #define szFileName "Hello.txt"
07. #define macro_Save(A) Print("Attempting to write in [",A,"] resulted in: ", FileSave(A, buff));
08. //+----------------+
09.     const string szText = "This file was created by a script written in MQL5.\nThis would be the contents of file number #%02d.";
10. //+----------------+
11.     uchar   buff[];
12.     ushort  counter = 1;
13. //+----------------+
14.     StringToCharArray(StringFormat(szText, counter++), buff);
15.     macro_Save(szFileName);
16. //+----------------+
17.     StringToCharArray(StringFormat(szText, counter++), buff);
18.     macro_Save(".\\Test\\" + szFileName);
19. //+----------------+
20.     StringToCharArray(StringFormat(szText, counter++), buff);
21.     macro_Save(".\\Temp\\" + szFileName);
22. //+----------------+
23.     StringToCharArray(StringFormat(szText, counter++), buff);
24.     macro_Save("..\\SandBox\\" + szFileName);
25. }
26. //+------------------------------------------------------------------+

Código 04

Aqui neste código 04, estaremos tentando escrever quatro arquivos diferentes em diferentes ramos dentro do que seria a SandBox MQL5\Files. Porém, em uma destas tentativas estaremos tentando sair da SandBox e escrever no que seria o diretório MQL5. Mas vamos ver isto com calma, para que você consiga entender como estas tentativas foram efetuadas e como interpretar o resultado das mesmas.

Primeiramente, quando este código 04 é executado no MetaTrader 5, teremos como resultado visto no terminal, algo semelhante a imagem mostrada logo abaixo.

Imagem 05

Note que em três dos casos, obtivemos sucesso na escrita do conteúdo do arquivo. Apesar de que, a princípio, não criamos nenhum diretório, fazendo uso de alguma outra chamada. O MetaTrader 5, conseguiu entender que seria necessário criar dois novos diretórios. Isto caso eles não existissem antes do código 04 ser executado.

Ok, então vamos dar uma olhada no tipo de conteúdo que foi escrito nos arquivos, e onde eles estariam localizados. Isto pode ser visto nas imagens logo abaixo.

Imagem 06

Imagem 07

Imagem 08

Note que em todas estas três imagens, estou marcando em verde a localização e o nome do arquivo. Mas observe com atenção o conteúdo em cada um dos arquivos. Você irá perceber que ele é quase igual, exceto o valor numérico presente na segunda linha. Este valor está aí apenas para diferenciar o conteúdo dos arquivos. Para que fique demonstrado, que podemos escrever arquivos diferentes de uma mesma maneira.

Porém apesar disto, vamos voltar a questão do código 04 em si. Note que nas linhas 15, 18, 21 e 24 estamos mudando apenas o nome do que seria o diretório a ser utilizado. No entanto, como você pode notar, na imagem 05, ao tentarmos criar o que seria o quarto arquivo, tivermos uma falha. Por que? O motivo, meu caro leitor, é que estamos tentando criar algo fora do que seria a SandBox atual. Ou seja, estamos tentando navegar para um ramo fora da raiz da SandBox. E ao tentarmos fazer isto, o MetaTrader 5, irá entender isto como um erro e impedirá que façamos algo no disco. Seja escrever, seja ler algum conteúdo de algum arquivo.

Sei que para muitos, isto que está sendo feito é um tanto quanto estranho. Já que a única diferença entre as linhas 18, 21 e 24, é a presença de um ponto extra na linha 24. Mas este ponto extra, diz ao sistema para que naveguemos em alguma direção diferente do atual ponto onde estamos. Porém, como estamos dentro de uma SandBox. E usando chamadas do MetaTrader 5 via MQL5. Somos impedidos de sair da SandBox. Mas a mesma coisa não aconteceria, se estivéssemos utilizando uma função de escrita presente no sistema operacional. Já que neste caso, o sistema operacional, não saberia da existência, ou presença da SandBox criada e mantida pelo MetaTrader 5. Daí, seria possível escrever, ler ou mesmo fazer qualquer outro tipo de coisa, em qualquer arquivo fora da SandBox.

Como não quero complicar muito este que talvez possa ser o primeiro contato seu, com este sistema de arquivo presente no MetaTrader 5. Vamos fazer uma última mudança no código. Isto a fim de que você possa experimentar a leitura de alguns dos arquivos que estarão sendo gravados pela nossa aplicação.

Para isto, vamos utilizar o código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06. #define szFileName "Hello.txt"
07. #define macro_Save(A) Print("Attempting to write in [",A,"] resulted in: ", FileSave(A, buff));
08. #define macro_Load(A) Print("Attempt to read the [",A,"] file resulted in: ", FileLoad(A, buff) != INVALID_HANDLE);
09. //+----------------+
10.     const string szText = "This file was created by a script written in MQL5.\nThis would be the contents of file number #%02d.";
11. //+----------------+
12.     uchar   buff[];
13.     ushort  counter = 1;
14. //+----------------+
15.     StringToCharArray(StringFormat(szText, counter++), buff);
16.     macro_Save(szFileName);
17. //+----------------+
18.     StringToCharArray(StringFormat(szText, counter++), buff);
19.     macro_Save(".\\Test\\" + szFileName);
20. //+----------------+
21.     StringToCharArray(StringFormat(szText, counter++), buff);
22.     macro_Save(".\\Temp\\" + szFileName);
23. //+----------------+
24.     StringToCharArray(StringFormat(szText, counter++), buff);
25.     macro_Save("..\\SandBox\\" + szFileName);
26. //+----------------+
27.     Print("+----------------+");
28.     ArrayResize(buff, 0);
29.     macro_Load(".\\Test\\" + szFileName);
30.     if (buff.Size() > 0)
31.         Print("File content:\n", CharArrayToString(buff));
32.     Print("+----------------+");
33.     ArrayResize(buff, 0);
34.     macro_Load(".\\Test 1\\" + szFileName);
35.     if (buff.Size() > 0)
36.         Print("File content:\n", CharArrayToString(buff));
37. }
38. //+------------------------------------------------------------------+

Código 05

Este código 05, irá lhe ajudar a entender como o sistema de SandBox funciona. Pelo menos a princípio este seria o objetivo dele. Isto por que, nele estamos tanto tentando escrever, quanto também tentando ler o conteúdo de um arquivo qualquer em uma dada localização. Apesar de aparentemente ser algo confuso. O mesmo é muito simples e direto. Isto desde que você tenha entendido o que foi mostrado no começo deste artigo. Tendo como resultado o que pode ser visto logo na imagem abaixo.

Imagem 09

Agora para entender todas estas mensagens, precisamos que você, tenha entendido o que foi feito no código 04 e o tipo de resultado que foi gerado ali. Tendo em vista que o resultado da execução do código 04 é exatamente a imagem 05. E que o conteúdo em cada um dos arquivos, pode ser visto nas imagens 06, 07 e 08. Precisamos nos preocupar com muita pouca coisa aqui neste código 05. Basicamente é preciso apenas explicar o que está ocorrendo a partir da linha 26. Pois é ali onde se inicia a leitura, ou tentativa de leitura dos arquivos.

Ok, você pode notar que nas linhas 29 e 34 estamos executando a macro presente na linha oito. O detalhe aqui é que quando está macro da linha oito é executada, será impresso uma mensagem no terminal. Dizendo qual o arquivo que estamos tentando ler. Assim como se foi o resultado foi bem sucedido ou não. Certo, até este ponto tudo bem normal e fácil de entender. Mas por que estamos usando as linhas 28 e 33 neste código? O motivo, meu caro leitor, é justamente limpar o array de dados. Como podemos ter uma falha durante a tentativa de leitura, não queremos que exista dados anteriores a isto. De forma que, quando o teste das linhas 30 e 35 forem executados, somente iremos imprimir algo no terminal, se de fato existir alguma coisa no array.

E considerando o fato de que na linha 34 estaremos tentando ler um arquivo, cujo a princípio, NÃO DEVERÁ EXISTIR, teremos uma mensagem de falha sendo impressa no terminal. Assim como também o teste da linha 35 falhando.

A princípio, você deve considerar o fato de que, tanto os arquivos, quanto também os diretórios presentes neste código 05 não deverão existir inicialmente. Isto para que o resultado seja adequado e devidamente apresentado como é visto na imagem 09. Caso você venha a ter um resultado diferente. Procure mudar o nome, ou até mesmo os diretórios envolvidos aqui neste código 05. Isto com o objetivo de criar tanto a falha que é vista ao tentar ler um arquivo que não existe. Como também o resultado da tentativa de ler um arquivo em um dado diretório.

Procure também, mudar o código de forma a usar a outra SandBox, vista neste artigo, que seria usando o parâmetro extra FILE_COMMON. Isto irá lhe ajudar a entender justamente aquela questão da imagem 04. Onde termos duas arvores com diferentes raízes.

Considerações finais

Neste artigo, demos o que seria os primeiros passos no sistema de arquivos presente e utilizado pelo MetaTrader 5. Com o objetivo de entender como a SandBox trabalha a fim de evitar que venhamos mexer em pontos não adequados dentro da arvore de diretórios presente no sistema operacional. Apesar da aparente complexidade inicial, isto pelo ponto de vista de quem esteja começando. Entender esta questão sobre como utilizar a SandBox é algo muito necessário para futuros projetos. Isto caso você realmente queira fazer uso massivo de arquivos a fim de armazenar dados, ou até mesmo criar configurações a serem mantidas e ajustadas ao longo do tempo.

Procure estudar este material com calma, meu caro leitor. Pois este passo que está sendo dado, precisa ser dado da maneira correta. Se você não entender como a SandBox funciona, terá serias dificuldades em resolver algumas questões futuras.

Arquivo MQ5	Descrição
Code 01	Demonstração de acesso a arquivos
Code 02	Demonstração de acesso a arquivos
Code 03	Demonstração de acesso a arquivos
Code 04	Demonstração de acesso a arquivos
Code 05	Demonstração de acesso a arquivos