Process: Una clase de múltiple uso

Iniciar ejecutables o documentos con la clase Process

Sin lugar a dudas esta será la forma más habitual de utilizar esta clase, ya que es la mejor forma de iniciar nuevos ejecutables, al menos desde Visual Basic, ya que en este lenguaje se puede utilizar también la función Shell para iniciar nuevas aplicaciones.

Lo importante de la clase Process (y de la función Shell de VB), es que con esta clase a diferencia de lo que ocurría antes (en VB6 por ejemplo), podemos iniciar no solo ejecutables (.exe), sino que también podemos iniciar cualquier tipo de "documento" siempre que la extensión de dicho documento esté asociada a un ejecutable.

Por ejemplo, si queremos iniciar Word lo tendríamos algo complicado, al menos si no sabemos dónde está alojado el ejecutable en nuestro disco duro, pero si lo tenemos instalado, y como suele ser, la extensión .doc la tenemos asociada a Word, podemos usar la clase Process para abrir dicho documento dentro de Word, sin necesidad de saber el path en el que está situado dicho ejecutable.

La forma más simple de iniciar un ejecutable o un documento con la clase Process es usando el método Start, que al estar compartido, lo podemos usar directamente, por ejemplo:

Process.Start("notepad.exe")

Aquí lo único que hacemos es indicarle como argumento del método Start el nombre del ejecutable o del documento, por ejemplo, si queremos abrir un documento de Word situado en el raíz del disco C, lo haríamos así:

Process.Start("C:\prueba.doc")

En estos dos ejemplos, no hemos tenido que crear ningún objeto en la memoria, ya que el método Start es un método compartido, por tanto siempre estará accesible.

En realidad el método Start no es "solo" un método compartido, ya que en realidad también es un método de instancia, es decir que lo podemos usar desde un objeto del tipo Process, aunque el método de instancia de la clase Process no recibe ningún parámetro, por tanto para poder usarlo antes tendríamos que indicar que es lo que queremos que se inicie, aunque eso lo veremos en un momento, antes aclaremos un poco cómo funcionan los métodos de instancia y compartidos en Visual Basic.

Por ejemplo, si tenemos el siguiente código:

Dim p As New
Process
p.Start("notepad.exe")

Esto funcionará bien en Visual Basic, independientemente de que estemos usando un método compartido desde una variable que apunta a un objeto recién creado. Pero en C# no funcionará, ya que C# no es tan "permisivo" como Visual Basic a la hora de usar los métodos compartidos (o estáticos que llaman en C# por

aquello de que se usa la instrucción static). En C# los métodos compartidos solo los podemos usar indicando la clase que los define, ya que en realidad, de eso se trata: los métodos compartidos pertenecen a la propia clase, por tanto siempre deberíamos usar la clase para acceder a ellos.

Y precisamente por eso, Visual Basic 2005 nos mostrará una advertencia si intentamos acceder a un método compartido desde una variable de instancia, pero como es habitual en la nueva versión de Visual Basic, también nos da la opción para corregir ese error, tal como podemos ver en la figura 1.

En este caso, el ejecutable compilará y funcionará como es de esperar, por tanto no es necesario hacer caso al "asistente" de VB2005, pero es bueno que lo sepamos y que debemos usar el método adecuado, ahora veremos cómo.

¿Cuál es la ventaja de usar el método compartido o el de instancia?

En realidad, para iniciar directamente un ejecutable o un documento, es decir, iniciarlo sin más, es más fácil usar el método compartido, de hecho el método Start ofrece varias sobrecargas, y precisamente las que reciben argumentos son las que están definidas en la propia clase como métodos compartidos, el método Start de instancia en realidad no recibe ningún parámetro, ya que la información que necesita la podemos indicar de otra forma: mediante un objeto del tipo ProcessStartInfo. Que como el propio nombre de la clase indica se utiliza para pasar información de inicio a la clase Process.

Veamos la forma más simple de usar esta clase:

Dim p As New Process
Dim
si As New
ProcessStartInfo("notepad.exe")
p.Start(si)

En este caso hemos creado un nuevo objeto del tipo ProcessStartInfo al que le pasamos como argumento del constructor el fichero que queremos iniciar, después le pasamos ese objeto al método Start y se iniciará el bloc de notas.

A la clase ProcessStartInfo le podemos indicar también el directorio de inicio de la aplicación, los argumentos que se pasarán al ejecutable (o documento), el estilo de la ventana, etc.

Pero esta no es la mejor forma de usar esa clase, ya que en realidad no hace falta crear una nueva instancia, porque la clase Process contiene un método llamado StartInfo al que le podemos indicar las mismas cosas que a esa clase.

Por ejemplo:

Dim p As New
Process
p.StartInfo.FileName = "notepad.exe"
p.StartInfo.WorkingDirectory = "C:\tmp"
p.StartInfo.Arguments = "prueba.txt"
p.StartInfo.WindowStyle = ProcessWindowStyle.Minimized
p.Start()

En este ejemplo, le indicamos el nombre del programa a iniciar, el directorio de inicio y como argumento el fichero de texto que queremos abrir con el bloc de notas y le indicamos que lo inicie minimizado.

Nota:
En estos ejemplos, estamos usando notepad.exe, pero para abrirlo no indicamos el path, esto es porque este programa está en el directorio de Windows y ese directorio se encuentra dentro del PATH del sistema, por tanto no es necesario indicarlo.
De hecho en la documentación de Visual Studio se indica que todo lo que podamos ejecutar desde Inicio>Ejecutar de Windows, lo podremos iniciar con el método Start de la clase Process.

Todos estos datos que le indicamos en el método StartInfo de la clase Process, también los podemos indicar de forma independiente y después asignarlo a la propiedad StartInfo o bien como argumento del método Start, tal como vimos anteriormente.

Por ejemplo, podemos usarlo así:

Dim p As New Process
Dim si As New
ProcessStartInfo
si.FileName = "notepad.exe"
si.WorkingDirectory = "C:\tmp"
si.Arguments = "prueba.txt"
si.WindowStyle = ProcessWindowStyle.Normal
p.Start(si)

O también así, (quitando la última línea del código anterior y añadiendo estas dos):

p. StartInfo = si
p.Start()

Cualquiera de estas formas es totalmente válida para iniciar un ejecutable o cualquier documento que tenga asociado algún programa que lo manipule.

Lo que debemos tener en cuenta es que esta última es en realidad la que debemos usar, al menos si lo que nos interesa es obtener información adicional del proceso recién iniciado, ya que como te he comentado anteriormente, cuando usamos el método Start con argumentos, en realidad estamos usando el método compartido de la clase Process, por tanto la instancia que hemos creado en realidad no se está utilizando. En realidad debemos ver la última línea de la primera parte del ejemplo anterior como:

Process.Start(si)

Y aunque le pasamos la información de inicio del proceso, en realidad no lo estamos relacionando con la variable que previamente hemos instanciado.