Receta C# No. 4-15: Cómo Iniciar un Nuevo Proceso

Índice

0. Introducción
1. Problema
2. Solución
3. Discusión de la Solución
4. Práctica: Código C#
5. Artefactos
6. Conclusiones
7. Glosario
8. Literatura & Enlaces

0. Introducción

Pasamos a la receta C# número 15 de la serie de threads, procesos, y sincronización. En esta gran oportunidad hablaremos acerca de cómo podemos manipular el inicio de la ejecución de un nuevo proceso a través del artefacto System.Diagnostics.Process y el método Start. Veremos que las versiones sobrecargadas de este método permiten un alto grado de control en la ejecución de una aplicación en un nuevo proceso, como: nombre del nombre a ejecutar, argumentos, nivel de seguridad, apertura condicional, modo de apertura, entre otras más. En los ejemplos prácticos demostraremos cómo trabajar con dos de las aplicaciones más comunes en el sistema operativo Windows: El bloc de notas, y el navegador Internet Explorer. ¡Manos a la obra!

1. Problema

Requerimos encontrar un mecanismo de inicio de procesos administrados y no administrados, y que además permita su parametrización al iniciarse.

2. Solución

Microsoft .NET Framework cuenta con la clase Process (System.Diagnostics) y un conjunto de métodos estáticos pertenecientes a esta misma clase, que permiten invocar un proceso y sus detalles de configuración (System.Diagnostics.ProcessStartInfo). 

3. Discusión de la Solución

La clase Process [3] posee varias versiones sobrecargadas del método Start. Estos métodos facilitan la representación administrada (e.g., gestión automática de memoria) de un proceso de sistema. A lo anterior también se puede agregar, que este mecanismo facilita la ejecución tanto de aplicaciones administradas y no administradas (en este caso es el propio sistema operativo que se encarga de la administración de recursos, manejo de excepciones, y recolección de basura).

Como ya mencionamos es través del método static Start [2] que podemos realizar esta tarea de ejecución de aplicaciones como un nuevo proceso en el sistema. Este método cuenta hasta con 6 versiones sobrecargadas. En la Figura 1 se muestra una breve descripción de estos métodos junto con su firma general:

Figura 1. Versiones sobrecargadas del método Process.Start [2].

Ahora, pasemos a estudiar la versión de cero-argumentos Start [4]. Esta es su firma:

public bool Start()

A diferencia de las demás versiones sobrecargadas, esta es el único método miembro de instancia, es decir, no static. Veamos el primer ejemplo de uso de este método:

Archivo C# UsoMetodoStart.cs [enlace alternativo]:

Para poder utilizar la versión de cero argumentos de Start, debemos crear una instancia de la clase Process: línea 11. Dentro del bloque try especificamos el nombre del ejecutable con una cadena de caracteres: "C:\\Windows\\notepad.exe".  Más adelante, línea 19, de forma explícita invocamos al método Start para iniciar la ejecución del Bloc de notas de Windows (notepad.exe).

Compilación:

1. csc /target:exe UsoMetodoStart.cs

Ejecución assembly:

1. .\UsoMetodoStart.exe

Prueba de ejecución:

Figura 2. Ejecución assembly UsoMetodoStart.exe.

Por otro lado, también contamos con una versión sobrecargada de Start apropiada para la ejecución de una aplicación con argumentos de línea de comandos; nos referimos a la versión con la siguiente firma [6]:

public static Process Start(string fileName, string arguments)

Descripción puntual:

• string fileName: Nombre del proceso a ejecutar.
• string arguments: Conjunto de argumentos a pasar al proceso apenas se inicie su ejecución.

Notemos, además, que esta versión retorna una instancia de Process, la cual corresponde con los detalles del proceso iniciado; en caso de una falla (e.g., archivo a ejecutar no encontrado) se retorna null.

Archivo C# EjecucionInternetExplorer.cs [enlace alternativo]:

En la línea 11 escribimos el nombre del archivo ejecutable de la aplicación Internet Explorer, luego, en la línea 14 la cadena de caracteres que representa el argumento, en este caso un URL de Blog xCSw. Finalmente, sobre la línea 17 la invocación del método Start con dos argumentos que comprenden el nombre del archivo a ejecutar, y el argumento (previamente especificados).

Compilación:

1. csc /target:exe EjecucionInternetExplorer.cs

Ejecución assembly:

1. .\EjecucionInternetExplorer.exe

Prueba de ejecución:

Figura 3. Ejecución assembly EjecucionInternetExplorer.exe.

Existe otra versión sobrecargada de Start que posee esta firma [5]:

public static Process Start(ProcessStartInfo startInfo)

El argumento startInfo de tipo ProcessStartInfo [7] permite al usuario de este método tener mayor control sobre la configuración y comportamiento que debería tener la aplicación al ejecutarse [1]. En la Figura 4 [1] se enumeran los propiedades de parametrización más comunes de este tipo de objeto:

Figura 4. Propiedades comunes de la clase ProcessStartInfo [1].

Pudimos haber utilizado esta versión sobrecargada para parametrizar el inicio de Internet Explorer como un nuevo proceso de la siguiente manera:

// Constructor de ProcessStartInfo con el nombre del
// proceso a ejecutar:
ProcessStartInfo startInfo = new ProcessStartInfo("IExplore.exe");

// Modo de la aplicación Minimizado:
startInfo.WindowStyle = ProcessWindowStyle.Minimized;

// Argumentos:
startInfo.Arguments = "http://ortizol.blogspot.com";

// Inicio del proceso con la parametrización del proceso:
Process.Start (startInfo);

Hay que tener en cuenta, la nota acerca de la liberación de recursos de procesos sugerida en [1]:

«When finished with a Process object, you should dispose of it in order to release system resources -call Close, call Dispose, or create the Process object within the scope of a using statement.»

4. Práctica: Código C#

Adaptaremos el ejemplo completo hallado en [1] para la ejecución del Bloc de notas de Windows en una ventana minimizada, además, estableceremos como argumento de inicio un archivo de texto plano almacenado en la raíz de la unidad de disco local C. Incluiremos la invocación del método WaitForExit de la clase Process el cual se encargará de bloquear el thread Main mientras el proceso notepad.exe finaliza.

Archivo C# EjecucionBlocDeNotas.cs [enlace alternativo]:

En la línea 12 creamos una instancia de la clase ProcessStartInfo a través del constructor de cero-argumentos. Luego (línea 15), a la propiedad FileName el asignamos la cadena de caracteres con el nombre del proceso a ejecutar (en este caso, notepad.exe); a la propiedad Arguments le asignamos el argumento que corresponde con el archivo de texto plano a visualizar. El directorio de trabajo, en donde estará almacenado el archivo de texto plano a abrir, será la raíz de la unidad de disco duro local C. La ventana de la aplicación se iniciará en modo normal: ProcessWindowStyle.Normal.

Continuando, en la línea 27 definimos una variable de tipo Process para representar el proceso en sí. Dentro del bloque try ocurren las siguientes tareas:

• Línea 32: Inicio del proceso con la parametrización almacenada en la variable startInfo.
• Línea 37: Invocación del método WaitForExit para la espera de la finalización del proceso.

Compilación:

1. csc /target:exe EjecucionBlocDeNotas.cs

Ejecución assembly:

1. .\EjecucionBlocDeNotas.exe

Prueba de ejecución:

Figura 4. Ejecución assembly EjecucionBlocDeNotas.exe.

5. Artefactos

Conjunto de artefactos producidos a lo largo de la generación de esta receta:

• R0415 (Mediafire)
• R0415 (MEGA)
• R0415 (4Shared)

6. Conclusiones

Comprendimos los esenciales para la ejecución de un proceso de forma administrada utilizando las versiones sobrecargadas del método Start de la clase Process. Este conocimiento y práctica nos será de enorme utilidad cuando en nuestras aplicaciones queramos asociar procesos externos como complemento a la lógica funcional inherente a la aplicación. En la siguiente receta C# aprenderemos los fundamentos sobre la terminación de un proceso, es decir, el completo a esta receta.

7. Glosario

• Administración de memoria
• Bloc de notas
• Gestión automática de memoria
• Internet Explorer
• Proceso
• Recolección de basura
• Sistema operativo

8. Literatura & Enlaces

[1]: Visual C# 2010 Recipes by Allen Jones and Adam Freeman. Copyright 2010 Allen Jones and Adam Freeman, 978-1-4302-2525-6.
[2]: Process.Start Method (System.Diagnostics) - http://msdn.microsoft.com/en-us/library/System.Diagnostics.Process.Start(v=vs.110).aspx
[3]: Process Class (System.Diagnostics) - http://msdn.microsoft.com/en-us/library/System.Diagnostics.Process(v=vs.110).aspx
[4]: Process.Start Method (System.Diagnostics) - http://msdn.microsoft.com/en-us/library/e8zac0ca(v=vs.110).aspx
[5]: Process.Start Method (ProcessStartInfo) (System.Diagnostics) - http://msdn.microsoft.com/en-us/library/0w4h05yb(v=vs.110).aspx
[6]: Process.Start Method (String, String) (System.Diagnostics) - http://msdn.microsoft.com/en-us/library/h6ak8zt5(v=vs.110).aspx
[7]: ProcessStartInfo Class (System.Diagnostics) - http://msdn.microsoft.com/en-us/library/system.diagnostics.processstartinfo(v=vs.110).aspx

J