Argumentos de línea de comandos en aplicaciones C# en 10 minutos o menos

¿Qué son los argumentos de línea de comandos?

Al principio, Tim explica por qué son importantes los argumentos de la línea de comandos. Las compara con la forma en que lanzamos herramientas como Docker, donde especificamos comandos como qué imagen cargar o qué tarea realizar. Del mismo modo, en las aplicaciones de línea de comandos de C#, se pueden pasar parámetros que definen el comportamiento del programa en tiempo de ejecución.

Por ejemplo, si estuviera ejecutando una aplicación de consola para procesar archivos, es posible que desee especificar la ruta del archivo o el modo a través de la entrada de la línea de comandos, en lugar de modificar el código.

Configuración del proyecto de consola

Tim comienza dentro de Visual Studio con un proyecto básico de aplicación de consola .NET 8. El código por defecto sólo imprime un mensaje como "Pulse return para salir", utilizando una sentencia Console.ReadLine() para esperar la entrada del usuario antes de cerrar.

Ahora, para manejar la entrada de la línea de comandos, Tim introduce la matriz args, que almacena los argumentos pasados a la aplicación cuando se ejecuta. Aunque las aplicaciones de consola de C# modernas utilizan sentencias de nivel superior, entre bastidores siguen teniendo un punto de entrada definido como:

static void Main(string[] args)

static void Main(string[] args)

o a veces:

static int Main(string[] args)

static int Main(string[] args)

Estas firmas representan el método principal, el punto de entrada donde comienza la ejecución. El parámetro args es una matriz de cadenas (string[]) que contiene todos los argumentos suministrados desde la línea de comandos.

Tim demuestra la iteración sobre la matriz args utilizando un bucle foreach:

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

Aquí, var arg representa cada argumento de cadena en la matriz args, y el programa los muestra en líneas separadas en la salida de la consola.

Tim señala que, aunque las declaraciones de nivel superior ocultan el código repetitivo, como la clase Program y el método Main, todo sigue funcionando igual: la matriz args está siempre disponible y lista para capturar argumentos de la línea de comandos.

Ejecución de la aplicación de consola

A continuación, Tim muestra cómo probar esta función. Ejecutar el programa normalmente dentro de Visual Studio no mostrará nada diferente, ya que no se ha proporcionado ninguna entrada de línea de comandos.

Para realizar la prueba correctamente, modifica manualmente el proceso de ejecución: abre el Explorador de archivos, navega hasta la carpeta bin → Debug → net8.0 del proyecto e inicia una ventana de terminal desde esa ruta.

A partir de ahí, utiliza el siguiente comando:

ConsoleArgs.exe "hello world" -t timing

ConsoleArgs.exe "hello world" -t timing

Este comando demuestra varios puntos clave:

• Las comillas "hola mundo" se tratan como un argumento de cadena, no como dos palabras separadas.

• La bandera -t y la palabra timing se tratan como dos argumentos adicionales.

Cuando se ejecuta, la salida de la consola muestra:

hello world  
-t  
timing

hello world  
-t  
timing

Cada argumento de línea representa un elemento de la matriz args. Tim explica que esto confirma el uso correcto de los argumentos de la línea de comandos: la aplicación de consola recibió y mostró correctamente todos los argumentos pasados durante la ejecución.

Menciona que los desarrolladores también pueden utilizar dotnet run en lugar de la ruta del ejecutable cuando se ejecuta desde un directorio de proyecto:

dotnet run -- "hello world" -t timing

dotnet run -- "hello world" -t timing

El guión doble (--) indica a .NET que debe tratar todo lo que aparece a continuación como parámetros de línea de comandos para su programa, no para la propia CLI de .NET.

Manejo y análisis de argumentos de línea de comandos

Ahora que podemos leer argumentos, Tim nos habla de cómo manejar los argumentos de la línea de comandos de forma inteligente.

Por ejemplo, si -t es una bandera que espera un valor, el programa debe saber que debe tratar el siguiente argumento de cadena como su valor. Tim muestra que se puede analizar manualmente comprobando los índices de la matriz args:

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

Este enfoque permite manejar argumentos con nombre, tipos numéricos e incluso indicadores de modo detallado. Tim señala que los desarrolladores suelen utilizar una sentencia switch o incluso documentación y bibliotecas externas para el análisis sintáctico de argumentos más avanzados, pero el espacio de nombres System y la matriz args ya proporcionan todo lo necesario para los casos básicos.

Ampliación a una aplicación Windows Forms

Tras mostrar las aplicaciones de consola, Tim pasa a una aplicación Windows Forms (WinForms).

En el código generado, el archivo Program.cs contiene un método estático void Main(), pero aún no acepta parámetros. Para habilitar los argumentos de la línea de comandos, Tim modifica manualmente el método Main para incluir el parámetro args:

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

Explica que args.FirstOrDefault() recupera el primer parámetro de entrada de la matriz args (o devuelve "default" si no se proporciona ningún argumento).

A continuación, en la clase Form1, Tim actualiza el constructor para que acepte un argumento de cadena:

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

Aquí, displayName es una etiqueta definida en el Diseñador de Windows Forms, y ahora muestra el argumento pasado a través de la línea de comandos.

Cuando ejecuta el programa sin argumentos, la etiqueta muestra "default" Cuando lo ejecuta de nuevo con:

WinFormsArgs.exe "Hello World"

WinFormsArgs.exe "Hello World"

la ventana del formulario muestra "Hello World"

Tim explica que esta técnica permite que las aplicaciones Windows Forms admitan argumentos de línea de comandos igual que las aplicaciones de consola, lo que ofrece a los usuarios la posibilidad de cambiar el comportamiento de inicio de forma dinámica.

Usos prácticos de los argumentos de la línea de comandos (7:18)

Tim concluye comentando lo versátiles que pueden llegar a ser las herramientas de línea de comandos con esta función. Los desarrolladores pueden utilizar argumentos de línea de comandos para:

• Iniciar aplicaciones en diferentes modos (por ejemplo, modo oscuro frente a modo claro).

• Proporcionar rutas de archivos u opciones de configuración al inicio.

• Habilite el modo detallado o las funciones de depuración mediante interruptores sencillos como -v o --debug.

• Crear accesos directos que pasen argumentos específicos para diferentes flujos de trabajo.