Del básico al intermedio: SandBox y MetaTrader

Introducción

En el artículo anterior Del básico al intermedio: Eventos en Objetos (IV), se explicó y se demostró cómo tú, mi querido lector, podrías desarrollar una metodología para redimensionar directamente en el gráfico algunos objetos que existieran allí. Como el objetivo aquí NO ES desarrollar ninguna aplicación, sino hacer una demostración para ejemplificar cómo tú, usando MQL5, puedes controlar y manipular las cosas en MetaTrader 5, no veo, en este momento, motivos para profundizar aún más en lo que se vio en ese artículo.

Podríamos ampliar, y mucho, ese tipo de implementación para conseguir hacer todavía más cosas. Mi interés y objetivo aquí son otros. Así, empezaremos a explorar otro tema, que también es muy importante que entiendas antes de querer aventurarte en otros tipos de actividades relacionadas con la programación.

Como de costumbre, vamos a pasar a un nuevo tema para hablar de lo que tratarán este y los próximos artículos.

Trabajando con archivos

Uno de los temas que puede llegar a volverse extremadamente avanzado, según lo que quieras hacer, es precisamente la necesidad de trabajar con archivos. Aunque muchos consideran este tema algo simple e incluso banal, dado el tipo de cosas que muchos suelen hacer o ver hacer, la realidad es muy distinta de lo que puede parecer.

Trabajar con archivos es, con diferencia, uno de los temas más complejos y difíciles de dominar. Esto se debe al simple hecho de que un archivo puede contener cualquier cosa. Y es eso, literalmente. El hecho de que mucha gente crea que es simple manipular archivos se debe precisamente a que, la mayoría de las veces, su contenido suele ser muy fácil de entender, precisamente por el tipo de información que aparece en esos archivos.

Sin embargo, dado que los archivos pueden contener información binaria, y esta puede ir desde valores numéricos o de configuración de una aplicación hasta la propia aplicación en sí, ya sea en forma de código objeto o, en gran parte de los casos, de opcodes de instrucción de máquina, no sorprende que este tema se vuelva extremadamente complejo con gran rapidez. Esto se debe, precisamente, al formato interno que puede llegar a tener el archivo.

Para que todos puedan entender, seguir y percibir qué podemos hacer y cómo hacerlo, empezaremos despacio, con un modelo más simple, al menos al principio. De este modo, a medida que vayas asimilando y captando los conceptos, podremos entrar en temas todavía más elaborados y complejos, pero siempre intentando mantener una explicación didáctica del tema.

Para empezar, necesitamos entender algo sobre MetaTrader 5 y sobre cómo maneja los archivos. Sí, existen diferencias entre usar MetaTrader 5 programando todo mediante MQL5 puro y usar MetaTrader 5 programando parte de las cosas fuera de MQL5. Necesitas entender esto antes de empezar realmente a trabajar con archivos.

Cuando usas MQL5 puro para programar algo que controle o manipule MetaTrader 5, quedas restringido a lo que se conoce como caja de arena, o SandBox. El término SandBox se usa mucho en la actualidad gracias a los sistemas operativos modernos, que permiten crear un entorno para ejecutar aplicaciones desconocidas de una forma algo más segura. Esto se debe a que la aplicación tendrá la impresión de poder hacer cualquier cosa. Sin embargo, cualquier cambio realizado se destruirá en cuanto se destruya la SandBox en la que se ejecutó la aplicación.

Esto garantiza que incluso una aplicación potencialmente dañina no dañe ningún archivo ni llegue a comprometer el sistema operativo con algún tipo de fallo. Es decir, una SandBox sería como una región segura, donde nada de lo que esté fuera de ella se verá afectado.

Pues bien, MetaTrader 5 trabaja con algo parecido. Tenemos una SandBox estándar cuando usamos MQL5 puro. Sin embargo, si llegamos a usar programación externa, o incluso alguna DLL, podemos hacer que esa SandBox de MetaTrader 5 se rompa. Esto permite acceder a zonas del disco o del sistema de archivos que están fuera de la SandBox de MetaTrader 5. Pero espera un momento, ¿no sería eso algo bueno? Porque podríamos grabar datos en dispositivos o en alguna parte del sistema de archivos a la que no tendríamos acceso de forma natural.

Bien, esta es una cuestión algo complicada de explicar en este momento, mi querido lector. Existen ventajas y desventajas al acceder a algo fuera de la SandBox. Sin embargo, por ahora, debes entender que esto es más peligroso que ventajoso. Si alguna aplicación que se ejecute en MetaTrader 5 llega a tener acceso fuera de la SandBox, podrá acceder a algo a lo que no debería. Y esto, en muchos casos, puede suponer un riesgo para la integridad de todos tus archivos.

Piensa en el hecho de que estarás ejecutando una aplicación para trabajar con dinero. Sin el debido cuidado, puedes llegar a ejecutar una aplicación en MetaTrader 5 que terminará teniendo acceso a algunos de tus archivos, a los que, en principio, no tendría acceso precisamente por las restricciones de la SandBox. Sin embargo, para que esto ocurra realmente, tú, como usuario, debes dar permiso para que la aplicación pueda hacerlo.

Normalmente, esto ocurre cuando habilitas lo que se muestra en la siguiente imagen.

Imagen 01

En esta imagen 01 tenemos el punto clave que puede permitir que una aplicación, al ejecutarse en MetaTrader 5, salga de la SandBox. Tanto es así que existe la advertencia de que esto puede ser perjudicial para el sistema si se habilita esta opción. Esto se debe, precisamente, a los riesgos de manipular archivos sin que MetaTrader 5 tenga el debido control. Una vez fuera de la SandBox, MetaTrader 5 ya no tendrá ningún control sobre lo que ocurra. Ese control pasará a estar en manos de la aplicación y de posibles llamadas a las DLL del sistema operativo. Aunque parezca seguro, una aplicación maliciosa puede usar las DLL del propio sistema operativo para causar daños catastróficos. ASÍ QUE, CUIDADO.

Bien, pero entonces ¿cómo nos protegería la SandBox en estos casos? Bien, esta es la parte realmente interesante, mi querido lector. Esto se debe a que los desarrolladores de MetaTrader 5 fueron bastante astutos al separar las cosas en pequeños bloques, donde cada bloque podría entenderse como la representación de una SandBox, totalmente aislada de las demás. Aunque en la práctica no es exactamente así. Pero esto lo irás entendiendo con el tiempo y a medida que vayas practicando lo que se mostrará y explicará.

Al principio, trabajaremos básicamente dentro de la SandBox de la forma más simple posible y sin muchas complicaciones. Esto te permitirá tanto crear como manipular archivos y directorios sin demasiado estrés ni riesgo de pérdida de datos. La SandBox fue pensada precisamente para eso.

Muy bien, entonces empecemos con algo muy simple y fácil de entender. Esto se hace usando el código que se muestra a continuación.

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 es un código de escritura de archivo muy simple y fácil de entender. Sin embargo, hay algo que ocurre cuando ejecutes este código y que puede dejarte un poco intrigado. Pero vayamos por partes. Primero, en la línea seis de este código 01, tenemos un mensaje que se escribirá en un archivo. Pero ¿en qué archivo? Bien, el nombre del archivo se indica en la línea once. Bien, pero ¿dónde se guardará este archivo? O, mejor dicho, ¿en qué directorio del disco debo buscar o esperar que se guarde este archivo? Bien, esto depende de algunas condiciones, mi querido lector. Tal como está escrito el código, se guardará dentro del directorio estándar de la SandBox de MetaTrader 5.

La ubicación exacta dentro del árbol de directorios dependerá de si estás ejecutando el código dentro de MetaTrader 5 o en un agente de pruebas. De todos modos, vamos a suponer que ejecutas todos los códigos directamente en MetaTrader 5. En ese caso, el archivo se grabará en la subcarpeta MQL5\Files. Esto puede verse en la siguiente imagen.

Imagen 02

Ahora, en esta misma imagen 02, puedes observar que una flecha señala un carácter extraño. Este carácter forma parte del archivo, ya que se guardó en él. Sin embargo, al mirar el mensaje de la línea seis, no vemos ningún indicio de la presencia de ese carácter. Entonces, ¿de dónde salió? Bien, mi querido lector, este carácter apareció debido a la línea nueve. Como estamos transformando una string en un array de caracteres para que la función de la línea once pueda grabar la string en el archivo, el carácter de fin de cadena también pasará a formar parte del contenido que se guardará, ya que no se eliminó de la string convertida en array.

Bien, pero ¿eso sería un problema? En principio, este hecho no representaría ningún problema, mi querido lector, siempre que seas consciente de que esto ocurre. Pero, como este código 01 es muy simple y está orientado a que tengamos el primer contacto con el sistema de archivos, no veo motivos para preocuparnos en este momento.

Bien, para demostrar que, en principio, ese contenido de la imagen 02, con ese carácter aparentemente extraño en el archivo, no representa un problema para nosotros, en este momento, vamos a modificar el código 01 para poder leer el archivo que se grabó e imprimir después su contenido en el terminal. Esto puede verse en el código 02, a continuación.

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

Bien, para garantizar que leeremos el mismo archivo que grabaremos, usamos la definición de la línea seis de este código 02 para indicar el nombre del archivo que se utilizará. Como las primeras líneas ya se explicaron antes, podemos pasar a la línea 16. Aquí leeremos el contenido del archivo y lo colocaremos en un array. En la línea 18, transformaremos este array de caracteres en una string, lo que nos permitirá imprimir el mismo mensaje que aparece en la línea ocho.

Para comprobarlo, cuando se ejecuta el código 02, podemos ver el resultado en la siguiente imagen.

Imagen 03

Es decir, funcionó como se esperaba. Este es el principio más simple de todos, en el que, con muy poco código, conseguimos almacenar y luego leer el contenido de un archivo, sin demasiado estrés ni complicaciones.

Ahora compliquemos las cosas solo un poco, para que empieces a entender ciertos detalles sobre esta cuestión de leer y escribir archivos. Para empezar, vamos a cambiar la SandBox. Para hacerlo, solo tendremos que modificar el código mostrado hasta aquí por el código que aparece a continuación.

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

Al ejecutar este código 03, verás el mismo resultado que aparece en la imagen 03. Sin embargo, si vas a buscar el archivo, notarás que no se está creando en la subcarpeta MQL5\Files. Se creará en otro lugar. Pero ¿dónde? Bien, antes de hablar de eso, observa que la única diferencia entre el código 02 y este código 03 es precisamente un parámetro extra que se añadió en las líneas 14 y 16, y que puede verse en este código 03.

Ahora, presta mucha atención, mi querido lector. Cuando el archivo se graba en la línea 14, este parámetro extra le indicará a MetaTrader 5 cuál será la SandBox que utilizará el archivo. Sin embargo, si durante la lectura, que se realiza en la línea 16, no se informa ese mismo parámetro, MetaTrader 5 buscará el archivo en la SandBox estándar, es decir, en la subcarpeta MQL5\Files. Y, con ello, podría darnos un resultado distinto del esperado: un error al leer o acceder al archivo o, en algunos casos, un contenido completamente extraño, muy diferente de lo que esperábamos encontrar.

Entonces, para que todo funcione de forma adecuada, tanto la lectura como la grabación deben coincidir en cuanto al lugar donde deba estar el archivo. De nada sirve indicar una SandBox durante la grabación e indicar otra durante la lectura, o viceversa. No sirve de nada esperar que MetaTrader 5 entienda lo que intentas hacer o a qué archivo estás intentando acceder. No tiene esa obligación ni tampoco interés en hacerlo.

Aunque, en algunos casos, sí podría llegar a encontrar el archivo correcto. Pero no cuentes con ello. Lo más probable es que termines escribiendo o leyendo en el lugar equivocado. Y eso puede arruinar tanto tu expectativa de encontrar cierto tipo de información como también cualquier dato que existiera en un archivo que, por una falla tuya, fue sobrescrito con datos nuevos.

Bien, ahora ya podemos intentar entender a qué SandBox apunta ese parámetro extra que se ve en las líneas 14 y 16 del código 03. Esto, para que puedas encontrar el archivo mediante algún otro editor, si quieres hacerlo. El parámetro FILE_COMMON le dice a MetaTrader 5 que utilice la subcarpeta \Terminal\Common\Files, así de simple. Pero espera un momento, déjame ver si entendí lo que está ocurriendo aquí. Cuando el parámetro FILE_COMMON no está presente, apuntamos a la SandBox MQL5\Files y, cuando está presente, apuntamos a la SandBox \Terminal\Common\Files. ¿Es eso? Sí, mi querido lector, eso es exactamente lo que ocurre. Pero yo imaginaba que deberíamos indicar el directorio para que este cambio se produjera. En cierto modo, esto me parece un poco confuso.

En realidad, no es tan confuso, mi querido lector. Tal vez te lo parezca precisamente porque todavía no entiendes el concepto de SandBox. Pero vayamos con calma, para que puedas entender este concepto y usarlo en las más diversas situaciones. Entenderlo adecuadamente es muy importante para que puedas sacar más partido a MetaTrader 5 en un conjunto más amplio de situaciones.

Entendiendo la SandBox

Para que entiendas adecuadamente el concepto de SandBox, o caja de arena, será necesario que tengas algún conocimiento sobre cómo funciona un sistema de archivos. Voy a dar una explicación rápida, solo para que algunos términos que se utilizarán en la explicación puedan tener sentido, para quienes no los conocen.

El primer término que hay que entender es el concepto de raíz. Una raíz sería como un punto inicial en un árbol de directorios. La idea de árbol viene del hecho de que cada rama de un árbol sería el equivalente a una subcarpeta dentro de un mismo directorio. Y cada hoja, en una de esas ramas, sería el equivalente a un archivo. Entonces, para simplificar, una raíz sería el directorio inicial. Cada árbol de directorios tendría una única raíz. A partir de esa raíz, tenemos inicialmente una rama. Cualquier hoja que esté en esa rama sería un archivo vinculado directamente a la raíz. Y un árbol NO tiene contacto directo con otro árbol. Es decir, NO existe un árbol con dos raíces distintas. Y todos están unidos al suelo.

Entendido esto, podemos empezar a hacer una analogía visual con lo que sería la SandBox presente en MetaTrader 5. Esto se muestra en la siguiente imagen.

Imagen 04

Esta imagen 04 representa dos SandBox, que fueron exactamente las que usamos en el tema anterior. Observa que la base inicial es la subcarpeta MetaQuotes\Terminal. Sin embargo, esta NO ES LA RAÍZ, sino el sustrato donde los árboles se encuentran alojados.

Ahora, fíjate en lo siguiente: el árbol #1 tiene una raíz que, en este caso, estaría en Common\Files. El árbol #2 tiene otra raíz, que estaría en MQL5\Files. Observa que no podemos pasar directamente de un árbol a otro sin antes pasar por lo que sería el sustrato. Normalmente, para hacer esto, es decir, pasar de una rama a otra, usaríamos un recurso. Sin embargo, aquí ese mismo recurso no podría utilizarse. Ya que un árbol sería como una SandBox, mientras que el otro árbol sería otra SandBox.

Para hacer esto un poco más claro y, al mismo tiempo, permitirte estudiar e intentar entender cómo podrían hacerse las cosas, vamos a modificar el código que vimos en el tema anterior para poder añadir directorios en nuestra rama. Hacer esto es algo muy simple y directo. Pero los resultados son realmente muy interesantes y, con ello, puede resultarte más fácil entender cómo funciona la SandBox en la práctica. Esto, con el fin de garantizar que todo quede bajo control. A continuación, podemos ver el código que usaremos al principio.

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

Aquí, en este código 04, intentaremos escribir cuatro archivos distintos en diferentes ramas dentro de la SandBox MQL5\Files. Sin embargo, en uno de estos intentos, trataremos de salir de la SandBox y escribir en el directorio MQL5. Veamos esto con calma, para que puedas entender cómo se realizaron estos intentos y cómo interpretar sus resultados.

En primer lugar, al ejecutar este código 04 en MetaTrader 5, veremos en el terminal un resultado similar al que aparece a continuación.

Imagen 05

Observa que, en tres de los casos, el contenido del archivo se escribió correctamente. Aunque, en principio, no creamos ningún directorio usando alguna otra llamada, MetaTrader 5 detectó que era necesario crear dos directorios nuevos. Esto, en caso de que no existieran antes de que se ejecutara el código 04.

Bien, entonces veamos el tipo de contenido que se escribió en los archivos y dónde están ubicados. Esto puede verse en las siguientes imágenes.

Imagen 06

Imagen 07

Imagen 08

Observa que, en estas tres imágenes, estoy marcando en verde la ubicación y el nombre del archivo. Pero fíjate bien en el contenido de cada uno. Verás que es casi igual, salvo por el valor numérico presente en la segunda línea. Ese valor está ahí solo para diferenciar el contenido de los archivos, y demostrar que podemos escribir archivos distintos de una misma manera.

Aun así, volvamos a la cuestión del propio código 04. Observa que, en las líneas 15, 18, 21 y 24, solo estamos cambiando el nombre del directorio que se va a utilizar. Sin embargo, como puedes ver en la imagen 05, al intentar crear el cuarto archivo se produjo un error. ¿Por qué? El motivo, mi querido lector, es que estamos intentando crear algo fuera de la SandBox actual. Es decir, estamos intentando ir a una rama que queda fuera de la raíz de la SandBox. Y, al intentar hacerlo, MetaTrader 5 lo interpretará como un error e impedirá que hagamos cualquier cosa en el disco, ya sea escribir o leer el contenido de algún archivo.

Sé que, para muchos, esto puede parecer un tanto extraño. La única diferencia entre las líneas 18, 21 y 24 es la presencia de un punto extra en la línea 24. Pero ese punto extra le indica al sistema que debe desplazarse en una dirección distinta desde la ubicación actual. Sin embargo, como estamos dentro de una SandBox y usamos llamadas de MetaTrader 5 mediante MQL5, no se nos permite salir de la SandBox. Pero esto no ocurriría si estuviéramos utilizando una función de escritura del propio sistema operativo. En ese caso, el sistema operativo no sabría de la existencia de la SandBox creada y mantenida por MetaTrader 5. Por eso, sería posible escribir, leer o incluso hacer cualquier otra cosa en cualquier archivo fuera de la SandBox.

Como no quiero complicar demasiado lo que quizá sea tu primer contacto con este sistema de archivos de MetaTrader 5, vamos a hacer un último cambio en el código para que puedas probar la lectura de algunos de los archivos que grabará nuestra aplicación.

Para ello, usaremos el código que se muestra a continuación.

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 te ayudará a entender cómo funciona el sistema de SandBox. Al menos, ese es su objetivo inicial. En él intentamos tanto escribir como leer el contenido de un archivo cualquiera en una ubicación determinada. Aunque pueda parecer algo confuso, es muy simple y directo si has entendido lo que se mostró al comienzo de este artículo, como se ve en la siguiente imagen.

Imagen 09

Ahora, para entender todos estos mensajes, es necesario que hayas entendido lo que se hizo en el código 04 y el tipo de resultado que se generó allí. Teniendo en cuenta que el resultado de la ejecución del código 04 es exactamente la imagen 05, y que el contenido de cada uno de los archivos puede verse en las imágenes 06, 07 y 08, aquí, en este código 05, hay muy pocas cosas que debamos considerar. Básicamente, solo hace falta explicar lo que ocurre a partir de la línea 26. Ahí es donde comienza la lectura, o el intento de lectura, de los archivos.

Bien, puedes notar que, en las líneas 29 y 34, estamos ejecutando la macro de la línea ocho. El detalle aquí es que, cuando se ejecuta esta macro de la línea ocho, se imprimirá un mensaje en el terminal indicando qué archivo estamos intentando leer, así como si el resultado tuvo éxito o no. Bien, hasta este punto todo es bastante normal y fácil de entender. Pero ¿por qué estamos usando las líneas 28 y 33 en este código? El motivo, mi querido lector, es precisamente limpiar el array de datos. Como podemos tener un fallo durante el intento de lectura, no queremos que queden datos anteriores. De este modo, cuando se ejecuten las comprobaciones de las líneas 30 y 35, solo imprimiremos algo en el terminal si, efectivamente, existe algún dato en el array.

Y, considerando que, en la línea 34, intentaremos leer un archivo que, en principio, NO DEBERÍA EXISTIR, se imprimirá un mensaje de fallo en el terminal, y la comprobación de la línea 35 también fallará.

En principio, debes considerar que tanto los archivos como los directorios presentes en este código 05 no deben existir inicialmente. Así, el resultado será el adecuado y se mostrará correctamente, como puede verse en la imagen 09. Si obtienes un resultado distinto, intenta cambiar el nombre, o incluso los directorios implicados en este código 05. El objetivo es generar tanto el fallo que se ve al intentar leer un archivo que no existe como también el resultado del intento de leer un archivo en un directorio determinado.

Intenta también modificar el código para usar la otra SandBox que se vio en este artículo, es decir, usando el parámetro extra FILE_COMMON. Esto te ayudará a entender precisamente lo que muestra la imagen 04, donde tenemos dos árboles con raíces diferentes.

Consideraciones finales

En este artículo dimos los primeros pasos en el sistema de archivos de MetaTrader 5, con el objetivo de entender cómo funciona la SandBox y evitar tocar puntos inadecuados dentro del árbol de directorios presente en el sistema operativo. A pesar de la aparente complejidad inicial, sobre todo desde el punto de vista de quien está empezando, entender esta cuestión sobre cómo utilizar la SandBox es algo muy necesario para proyectos futuros. Esto, si realmente quieres hacer un uso intensivo de archivos para almacenar datos o incluso crear configuraciones que se mantengan y ajusten con el tiempo.

Procura estudiar este material con calma, mi querido lector. Porque este paso debe darse de la manera correcta. Si no entiendes cómo funciona la SandBox, tendrás serias dificultades para resolver algunas cuestiones futuras.

Archivo MQ5	Descripción
Code 01	Demostración de acceso a archivos
Code 02	Demostración de acceso a archivos
Code 03	Demostración de acceso a archivos
Code 04	Demostración de acceso a archivos
Code 05	Demostración de acceso a archivos