Cargar Archivos
La funcion de abrir un archivo al cargar el programa: explicada
Bueno, para aquellos interesados, aquí les tengo un pequeño tutorial para implementar una de las funciones más comunes y deseadas, y a la vez más complicadas de conseguir al momento de hacer un programa: Hacer que el programa abra automáticamente un archivo al hacer doble click en él. ¿Suena un poco enredado? No lo es tanto, créanme. Acompáñenme y lo comprobarán. ^_^
Debo hacer notar que este tutorial un cierto conocimiento de programación en general, para poder manejar una serie de cosas que se hacen necesarias durante el trabajo. También, este tutorial está pensado para reproducirse con Visual Studio .NET y más específicamente con el Visual Basic .NET, en cualquiera de las versiones, aunque la idea general se puede aplicar en cualquier otro lenguaje. (Sólo hay que conseguir la variable clave que mencionaré más adelante.)
Una vez aclarado esto, prosigamos.
» Paso Número Cero: Crea Tu Propia Extensión De Archivo
Se preguntarán por qué el número cero para este paso. Sencillo: algunos querremos hacer nuestro propio tipo de archivo, y otros sencillamente querremos utilizar alguno de los ya existentes. Cualquiera de las opciones que elijas da lo mismo para este caso, así que no te asustes. ;)
Lo primero es que debemos pensar en qué extensión utilizaremos. Por razones de videojuegos (no pregunten =p), decidí perder un poco de tiempo haciendo un programita para llevar un listado simple capaz de abrir sus propias listas.
Para ello, y como quise darle un poco de personalidad a mi programa, me tomé la molestia de crear una nueva extensión representativa de mi programa, ".rmz3". Con eso identifico que todos los archivos que existen con esa extensión, son para uso con mi programita.
Una vez que esto está hecho, o si decidimos no usarlo, vamos al siguiente paso.
» Paso Número Uno: Creando El Programa
Bien, ya tienes tu extensión. Ahora falta crear el programa, que es lo más importante. No profundizaré sobre cómo hacerlo, sino que para el caso, iremos directamente a suponer que ya lo tienes hecho, y que sólo quieres implementar esta función.
Lo primero que tienes que hacer es asegurarte de que tu subrutina o procedimiento para abrir archivos no esté sujeto a ningún evento (como por ejemplo, cuando cliqueas un botón o algo parecido), sino que sea un procedimiento/subrutina independiente. El mío es el siguiente:
Code:
| Public Sub loadData(ByVal fileName As String) If IO.File.Exists(fileName) = True Then resetAll() initializeChecks() Dim Stream As StreamReader Dim File As FileStream Dim filecontents As String = vbNullString File = New FileStream(fileName, FileMode.Open) Stream = New StreamReader(File) Stream.ReadLine() Dim i As Integer For i = 1 To 18 filecontents = filecontents & Stream.ReadLine Next Stream.Close() File.Close() For i = 0 To 179 Select Case filecontents.Chars(i) Case Is = "1" checks(i).Checked = True Case Is = "0" checks(i).Checked = False End Select Next stats.Text = "File successfully loaded" report() Refresh() End If End Sub |
Como intepretarán, es algo muy simple: leo dieciocho líneas compuestas de ceros y unos, y dependiendo de los resultados, los botones de la interface se van presionando o quedándose como están a discreción.
En lo que sea que vayas a utilizar tu subrutina de abrir el archivo, debes hacer una llamada a tu procedimiento/subrutina independiente. En mi caso, es así:
Code:
| Private Sub loadDB_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles loadDB.Click initializeChecks() openfile.ShowDialog() loadData(openfile.FileName) End Sub |
En la primera línea, llamo un procedimiento que me hace una inicialización forzada del programa, y en la segunda, llamo mi cuadro de diálogo de Abrir Archivo. La tercera es la llamada formal a mi subrutina para verdaderamente abrir el archivo, y reflejar la data contenida en mi programa.
Punto clave: Fíjense que al momento de llamar la subrutina de abrir, utilizo la ruta de archivo como un parámetro de la subrutina. Esto nos facilitará el trabajo más adelante.
Bien, una vez que esto funciona, estamos a un paso de obtener lo que queremos: abrir con un doble click nuestro archivo.
» Paso Número Dos: Asociando El Tipo De Archivo
Una vez que tenemos nuestro procedimiento o subrutina para abrir archivos definido, es hora de asociar la extensión. Haz click derecho en el archivo, y vete a las propiedades. En el cuadro de diálogo de propiedades, hay una opción que dice "Se abre con" ("Opens with"). Dale a Cambiar ("Change"), y busca tu programa. Dale a aceptar a todo, y ahora tu archivo debe estar asociado. ¿Cómo lo comprobamos? Haz doble click en él. Si todo está correcto, debe automáticamente abrir tu programa... Pero verás que éste no hace nada respecto al archivo. Bien, en poco tiempo corregiremos eso.
» Paso Número Tres: Creando El Código Para Abrir En La Llamada
Nada más sencillo. Vayamos al código de nuestro programa. En algún lugar debe haber una subrutina de evento, que se ejecuta cuando carga el programa. En .NET se llama "MyBase.Load". Esa es exactamente la parte que queremos.
Ahora viene lo interesante. Vamos a declarar un arreglo dinámico de tipo String, dentro de la subrutina de carga del programa, al que le llamaremos Comando:
Code:
| Dim Comando() As String |
Sencillo, ¿no? Lo interesante es lo que sigue: vamos a hacer que al momento de inicializarse, automáticamente se llene con una de las variables especiales predefinidas del sistema, cuya función es guardar todos los parámetros que se recogen al momento de ejecutar el programa:
Code:
| Dim Comando() As String = Environment.GetCommandLineArgs |
Se preguntarán de donde viene esa variable. Pues bien, ella es la clave de todo este asunto. Veamos cómo funciona:
Al momento de llamar cualquier programa mediante la interface de Windows, realmente estamos enviando un comando de la línea de comandos que llama dicho ejecutable. Si hacemos doble click en un archivo, realmente lo que hacemos es enviar a la línea de comandos el nombre del ejecutable, y encima de ello, el nombre y ruta completos del archivo que estamos cliqueando. Me explico: Supongamos que tienes un programa que se llama "prueba.exe", en la carpeta "pruebas" dentro del disco C. Esto nos dice que la ruta completa del ejecutable sería "C:pruebasprueba.exe". Si tenemos un archivo "notas.xxx" dentro de la carpeta "archivos" en el disco D, por poner un ejemplo, si está asociado con ese programa, y hacemos doble click en él, la línea de comandos del sistema guardará en un arreglo dinámico el nombre y ruta del ejecutable, y el nombre y ruta del archivo. En nuestro caso, el resultado sería éste:
C:/pruebas/prueba.exe" "D:/archivos/notas.xxx
¿Ven? Es sencillo; y a partir de ahora todo se hace más claro aún. Lo que haremos es que, una vez que el arreglo que declaramos arriba se llena con éstas variables, primero revisamos si tiene más de un elemento:
Code:
| If Comando.Length > 1 Then |
Si lo tiene, tomamos esa ruta, y se la enviamos como parámetro a nuestra subrutina de abrir archivo:
Code:
| If Comando.Length > 1 Then openFile(Comando(1)) End If |
Automáticamente, al momento de cargar el programa, el código revisará si le estamos mandando algún parámetro (una ruta de archivo); de ser así, automáticamente llama nuestro archivo; y si no lo tiene, pos sencillamente no hace nada. =p
» Conclusión
En general, esa es la idea básica. Se puede adaptar a miles de posibilidades, como aceptar parámetros especiales (validando las cadenas de caracteres en las posiciones de los parámetros), posibilitar abrir múltiples archivos al mismo tiempo, y una infinidad de cosas más. Yo personalmente estoy adaptándolo para utilizarse al momento de abrir múltiples archivos, al estilo del Photoshop u otro programa parecido. Lo único que limita el uso de este código es la imaginación, de veras. =p
Espero que les haya gustado, y más importante, que lo hayan entendido. ^_^