Parsear los argumentos de la línea de comando

Para determinadas situaciones, es más útil parametrizar nuestras aplicaciones desde los argumentos que pasamos al ejecutable que desde un archivo de configuración, sobre todo si es una aplicación de consola. El problema suele ser que lo que nos llega a nuestra aplicación es un array de cadenas y nosotros debemos relacionarlas entre ellas, pudiendo haber distintos tipos de elemetos como modificadores, parámetros, parámetros de los modificadores y distintas cantidades de ambos tipos de parámetros.

Este es un ejemplo de como ordenarlos obteniendo una estructura en la que todo esta ordenado en forma jerárquica para poder consultar fácilmente parámetros, modificadores y parámetros de los modificadores, la función devuelve una clase de este tipo:

public class CommandLineArguments
{
    public List<String> Parameters { get; private set; }
    public Dictionary<String, List<String>> Modifiers { get; private set; }
 
    public CommandLineArguments()
    {
        this.Parameters = new List<String>();
        this.Modifiers = new Dictionary<String, List<String>>();
    }
}

La función recorre el array de argumentos (args[]) identificando cada uno por su relación y posición y colocandolo en la clase anterior:

delegate void ModParFinder_(String key, Int32 current);
static CommandLineArguments ParseParameters(String[] args, Char modIndicator)
{
    CommandLineArguments cmdArgs = new CommandLineArguments();
 
    // Busca los parametros de un modificador y los 
    // añade a la clave dada
    ModParFinder_ ModParFinder =
        new ModParFinder_(delegate(String key, Int32 current)
        {
            current++;
 
            if (!cmdArgs.Modifiers.ContainsKey(key))
                cmdArgs.Modifiers.Add(key, new List<String>());
 
            while (current < args.Length && !args[current].StartsWith(modIndicator.ToString()))
            {
                cmdArgs.Modifiers[key].Add(args[current]);
                current++;
            }
        });
 
    Boolean modsFound = false;
    if (args != null)
        for (Int32 i = 0; i < args.Length; i++)
        {
            if (args[i].StartsWith(modIndicator.ToString()))
            {
                ModParFinder.Invoke(args[i], i);
                modsFound = true;
            }
            else if (!modsFound)
                cmdArgs.Parameters.Add(args[i]);
        }
 
    return cmdArgs;
}

Para usar y consultar esta funcionalidad, un sencillo ejemplo:

static Int32 Main(String[] args)
{
    Console.WriteLine(Environment.CommandLine);
 
    CommandLineArguments cmdL = ParseParameters(args, '-');
 
    // Mostrar la información recabada
 
    Console.WriteLine("Parameters: ");
    foreach (String s in cmdL.Parameters)
    {
        Console.WriteLine("  " + s);
    }
 
    Console.WriteLine("Modifiers: ");
    foreach (String k in cmdL.Modifiers.Keys)
    {
        Console.WriteLine(k+": ");
        foreach (String s in cmdL.Modifiers[k])
            Console.WriteLine("  " + s);
    }
 
    Console.ReadKey(true);
    return 0;
}

Por ejemplo, si ejecutamos la aplicación y le pasamos los siguientes argumentos:

MiApp.exe "C:Archivos de programapath largo" -s smod -l "lmod largo" 123 -w wmod1 wmod2 -h -j

El resultado será el siguiente :

Parameters:
C:Archivos de programapath largo
Modifiers:
-s:
smod
-l:
lmod largo
123
-w:
wmod1
wmod2
-h:
-j:

Luego el validar la cantidad y corrección de los parámetros y modificadores… a gusto de cada uno 😀

Parsear los argumentos de la linea de comando | vtortola.NET

3 comentarios en “Parsear los argumentos de la línea de comando”

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *