Cómo usar argumentos de línea de comandos en C#

Los argumentos de línea de comandos son valores que pasamos a una aplicación al iniciarla para configurar su comportamiento sin modificar el código.

En C#, puedes recibirlos mediante el parámetro string[] args del método Main y acceder a cada argumento por su posición.

Cómo recibe C# los argumentos

Cuando se ejecuta un programa de consola, es común que los usuarios proporcionen parámetros de entrada en la línea de comandos. Por ejemplo, si tienes una aplicación llamada MiAplicacion.exe, los argumentos de consola pueden ser pasados como sigue:

MiAplicacion.exe archivo.txt /modo=debug /verbose

En este ejemplo, archivo.txt, /modo=debug y /verbose son los argumentos de la consola. Estos argumentos permiten que la aplicación reciba datos o directrices sobre cómo debe comportarse durante su ejecución.

En C#, el método Main de la clase principal del programa puede aceptar estos argumentos a través de un parámetro string[] args:

class Program
{
    static void Main(string[] args)
    {
        // Aquí `args` contendrá los argumentos pasados desde la línea de comandos
    }
}

Estructura del método Main

El método Main puede recibir argumentos de dos formas diferentes:

1. Con un parámetro de tipo string[]: Esta es la forma más común. Permite acceder a todos los argumentos pasados al programa.

   static void Main(string[] args)
   {
       // `args` es un arreglo de cadenas
   }

   Copied!

2. Sin parámetros: En este caso, no se pueden recibir argumentos desde la línea de comandos.

   static void Main()
   {
       // No se pueden acceder a los argumentos
   }

   Copied!

Acceder a los argumentos

Los argumentos pasados a la línea de comandos están disponibles en el parámetro args como un arreglo de cadenas. Cada argumento proporcionado por el usuario se almacena en una posición específica dentro del arreglo.

Ejemplo básico

Consideremos una aplicación que recibe tres argumentos: un archivo, un modo de ejecución y una opción de depuración.

using System;

class Program
{
    static void Main(string[] args)
    {
        if (args.Length < 3)
        {
            Console.WriteLine("Se requieren al menos tres argumentos: archivo, modo y opción.");
            return;
        }

        string archivo = args[0];
        string modo = args[1];
        string opcion = args[2];

        Console.WriteLine("Archivo: " + archivo);
        Console.WriteLine("Modo: " + modo);
        Console.WriteLine("Opción: " + opcion);
    }
}

Ejecutar la aplicación

Si ejecutamos el programa de la siguiente manera:

MiAplicacion.exe datos.txt modo=debug /verbose

La salida sería:

Archivo: datos.txt
Modo: modo=debug
Opción: /verbose

Cada valor se puede acceder por su índice en el arreglo args.

Comprobar el número de argumentos

Es fundamental comprobar si el número de argumentos es el esperado para evitar errores de acceso a índices fuera de los límites del arreglo. En el ejemplo anterior, el programa verifica si hay al menos tres argumentos antes de intentar acceder a ellos.

Analizar argumentos de consola

En muchos casos, los argumentos de consola tienen un formato específico, como pares clave-valor (por ejemplo, /modo=debug) o valores con banderas (por ejemplo, /verbose). Para gestionar estos tipos de argumentos, es común escribir un análisis (parsing) que convierta los argumentos en configuraciones utilizables.

Analizar argumentos de tipo clave-valor

A continuación, se presenta un ejemplo en el que procesamos un conjunto de argumentos con un formato clave-valor:

using System;

class Program
{
    static void Main(string[] args)
    {
        string modo = "default";
        bool verbose = false;

        foreach (var arg in args)
        {
            if (arg.StartsWith("/modo="))
            {
                modo = arg.Substring(6); // Elimina "/modo="
            }
            else if (arg == "/verbose")
            {
                verbose = true;
            }
        }

        Console.WriteLine("Modo: " + modo);
        Console.WriteLine("Verbose: " + verbose);
    }
}

Ejecución

Al ejecutar el programa con los siguientes argumentos:

MiAplicacion.exe /modo=debug /verbose

La salida sería:

Modo: debug
Verbose: True

Este código analiza los argumentos, buscando aquellos que empiezan con /modo= y asigna su valor. Si encuentra el argumento /verbose, cambia la configuración de la opción verbose.

Validar los argumentos

Una parte importante al gestionar los argumentos de la consola es la validación. Es fundamental asegurarse de que los valores proporcionados sean correctos y cumplan con los requisitos del programa.

Validar un archivo y un modo

Supongamos que el programa necesita que el archivo proporcionado sea válido y que el modo de ejecución debe ser uno de los valores predefinidos: debug, release, o test. Si el argumento no cumple con estas condiciones, el programa debería notificar al usuario y terminar de manera adecuada.

using System;

class Program
{
    static void Main(string[] args)
    {
        if (args.Length < 2)
        {
            Console.WriteLine("Se requieren al menos dos argumentos: archivo y modo.");
            return;
        }

        string archivo = args[0];
        string modo = args[1];

        // Validación del archivo
        if (!System.IO.File.Exists(archivo))
        {
            Console.WriteLine("El archivo especificado no existe.");
            return;
        }

        // Validación del modo
        if (modo != "debug" && modo != "release" && modo != "test")
        {
            Console.WriteLine("El modo debe ser 'debug', 'release' o 'test'.");
            return;
        }

        Console.WriteLine($"Archivo: {archivo}");
        Console.WriteLine($"Modo: {modo}");
    }
}

Ejecución

Si el archivo no existe o el modo es incorrecto, el programa muestra un mensaje de error. Esto garantiza que los argumentos sean válidos antes de continuar con la ejecución.

Gestionar argumentos opcionales

Algunas veces, los argumentos de la consola no son obligatorios, y queremos permitir que el usuario decida si desea incluirlos. Por ejemplo, podríamos querer que el programa reciba un archivo, pero el modo podría ser opcional.

using System;

class Program
{
    static void Main(string[] args)
    {
        string archivo = "default.txt";
        string modo = "release";

        if (args.Length > 0)
        {
            archivo = args[0];
        }

        if (args.Length > 1)
        {
            modo = args[1];
        }

        Console.WriteLine($"Archivo: {archivo}");
        Console.WriteLine($"Modo: {modo}");
    }
}

Ejecución

Al ejecutar el programa con:

MiAplicacion.exe datos.txt

La salida sería:

Archivo: datos.txt
Modo: release

Si no se proporcionan los argumentos, el programa utilizará los valores predeterminados.