Pregunta ¿La mejor forma de analizar argumentos de línea de comando en C #? [cerrado]


Al construir aplicaciones de consola que toman parámetros, puede usar los argumentos pasados ​​a Main(string[] args).

En el pasado simplemente he indexado / bucle esa matriz y he hecho algunas expresiones regulares para extraer los valores. Sin embargo, cuando los comandos se vuelven más complicados, el análisis puede ser bastante feo.

Entonces estoy interesado en:

  • Bibliotecas que usa
  • Patrones que usa

Asuma que los comandos siempre se adhieren a estándares comunes tales como respondió aquí.


733
2018-01-29 13:33


origen


Respuestas:


Sugeriría usar NDesk.Options (Documentación) y / o Mono.Options (misma API, espacio de nombres diferente). Un ejemplo de la documentación:

bool show_help = false;
List<string> names = new List<string> ();
int repeat = 1;

var p = new OptionSet () {
    { "n|name=", "the {NAME} of someone to greet.",
       v => names.Add (v) },
    { "r|repeat=", 
       "the number of {TIMES} to repeat the greeting.\n" + 
          "this must be an integer.",
        (int v) => repeat = v },
    { "v", "increase debug message verbosity",
       v => { if (v != null) ++verbosity; } },
    { "h|help",  "show this message and exit", 
       v => show_help = v != null },
};

List<string> extra;
try {
    extra = p.Parse (args);
}
catch (OptionException e) {
    Console.Write ("greet: ");
    Console.WriteLine (e.Message);
    Console.WriteLine ("Try `greet --help' for more information.");
    return;
}

324
2018-01-14 22:06



Me gusta mucho la biblioteca Command Line Parser ( http://commandline.codeplex.com/ ) Tiene una forma muy simple y elegante de configurar los parámetros a través de atributos:

class Options
{
    [Option("i", "input", Required = true, HelpText = "Input file to read.")]
    public string InputFile { get; set; }

    [Option(null, "length", HelpText = "The maximum number of bytes to process.")]
    public int MaximumLenght { get; set; }

    [Option("v", null, HelpText = "Print details during execution.")]
    public bool Verbose { get; set; }

    [HelpOption(HelpText = "Display this help screen.")]
    public string GetUsage()
    {
        var usage = new StringBuilder();
        usage.AppendLine("Quickstart Application 1.0");
        usage.AppendLine("Read user manual for usage instructions...");
        return usage.ToString();
    }
}

198
2017-09-07 07:29



los Biblioteca WPF TestApi viene con uno de los mejores analizadores de línea de comandos para el desarrollo de C #. Recomiendo investigarlo, desde El blog de Ivo Manolov sobre la API:

// EXAMPLE #2:
// Sample for parsing the following command-line:
// Test.exe /verbose /runId=10
// This sample declares a class in which the strongly-
// typed arguments are populated
public class CommandLineArguments
{
   bool? Verbose { get; set; }
   int? RunId { get; set; }
}

CommandLineArguments a = new CommandLineArguments();
CommandLineParser.ParseArguments(args, a);

50
2018-01-29 14:12



Mirar http://github.com/mono/mono/tree/master/mcs/class/Mono.Options/


24
2018-01-29 13:40



Parece que todos tienen sus propios analizadores de línea de comandos para mascotas, y es mejor que agregue los míos también :).

http://bizark.codeplex.com/

Esta biblioteca contiene un analizador de línea de comandos eso inicializará una clase con los valores de la línea de comando. Tiene un montón de características (lo he estado construyendo durante muchos años).

Desde el documentación...

El análisis de línea de comandos en el marco de BizArk tiene estas características clave:

  • Inicialización automática: Las propiedades de clase se establecen automáticamente en función de los argumentos de la línea de comandos.
  • Propiedades predeterminadas: Envíe un valor sin especificar el nombre de la propiedad.
  • Conversión de valor: Utiliza la poderosa clase ConvertEx también incluida en BizArk para convertir valores al tipo apropiado.
  • Indicadores booleanos: Los indicadores se pueden especificar simplemente usando el argumento (ex, / b para verdadero y / b- para falso) o agregando el valor verdadero / falso, sí / no, etc.
  • Arrays de argumento: Simplemente agregue varios valores después del nombre de la línea de comando para establecer una propiedad que se define como una matriz. Ex, / x 1 2 3 poblará x con la matriz {1, 2, 3} (suponiendo que x se define como una matriz de enteros).
  • Alias ​​de línea de comandos: Una propiedad puede admitir múltiples alias de línea de comandos para ella. Por ejemplo, ¿Ayuda usa el alias?
  • Reconocimiento parcial del nombre: No es necesario que deletree el nombre completo o el alias, solo deletree lo suficiente para que el analizador elimine la ambigüedad de la propiedad / alias de los demás.
  • Admite ClickOnce: Puede inicializar propiedades incluso cuando se especifican como la cadena de consulta en una URL para aplicaciones desplegadas ClickOnce. El método de inicialización de la línea de comandos detectará si se está ejecutando como ClickOnce o no, por lo que no es necesario que el código cambie al usarlo.
  • Crea automáticamente /? ayuda: Esto incluye un buen formato que tiene en cuenta el ancho de la consola.
  • Cargar / guardar argumentos de línea de comandos en un archivo: Esto es especialmente útil si tiene múltiples conjuntos grandes y complejos de argumentos de línea de comandos que desea ejecutar varias veces.

14
2017-07-01 01:03



Hace un tiempo escribí un analizador de argumentos de línea de comando C #. Está en: http://www.codeplex.com/CommandLineArguments


13
2017-12-15 07:07



APLAUDIR (el analizador de argumentos de línea de comandos) tiene una API utilizable y está maravillosamente documentado. Haces un método, anotando los parámetros. https://github.com/adrianaisemberg/CLAP


9
2018-03-15 15:11



Hay numerosas soluciones a este problema. Para completar y proporcionar la alternativa si alguien desea estoy agregando esta respuesta para dos clases útiles en mi biblioteca de código de google.

El primero es ArgumentList, que es el único responsable de analizar los parámetros de la línea de comando. Recoge pares de nombre-valor definidos por los modificadores '/ x: y' o '-x = y' y también recopila una lista de entradas 'sin nombre'. Es básico el uso se discute aquí, ver la clase aquí.

La segunda parte de esto es la CommandInterpreter que crea una aplicación de línea de comandos completamente funcional fuera de tu clase .Net. Como ejemplo:

using CSharpTest.Net.Commands;
static class Program
{
    static void Main(string[] args)
    {
        new CommandInterpreter(new Commands()).Run(args);
    }
    //example ‘Commands’ class:
    class Commands
    {
        public int SomeValue { get; set; }
        public void DoSomething(string svalue, int ivalue)
        { ... }

Con el código de ejemplo anterior, puede ejecutar lo siguiente:

Program.exe DoSomething "valor de cadena" 5

- o -

Program.exe dosomething / ivalue = 5 -svalue: "valor de cadena"

Es tan simple como eso o tan complejo como lo necesites. Usted puede revisa el código fuente, ver la ayuda, o descarga el binario.


5
2018-05-11 18:25



me gusta ese, porque puedes "definir reglas" para los argumentos, necesarios o no, ...

o si eres un chico de Unix, de lo que te gustaría GNU Getopt .NET Puerto.


4
2018-01-29 13:43



Puede que te guste mi Rug.Cmd

Analizador de argumentos de línea de comando fácil de usar y expandible. Controles: Bool, Plus / Minus, String, String List, CSV, Enumeration.

Construido en '/?' modo de ayuda

Construido en '/ ??' y modos de generador de documentos '/? D'.

static void Main(string[] args) 
{            
    // create the argument parser
    ArgumentParser parser = new ArgumentParser("ArgumentExample", "Example of argument parsing");

    // create the argument for a string
    StringArgument StringArg = new StringArgument("String", "Example string argument", "This argument demonstrates string arguments");

    // add the argument to the parser 
    parser.Add("/", "String", StringArg);

    // parse arguemnts
    parser.Parse(args);

    // did the parser detect a /? argument 
    if (parser.HelpMode == false) 
    {
        // was the string argument defined 
        if (StringArg.Defined == true)
        {
            // write its value
            RC.WriteLine("String argument was defined");
            RC.WriteLine(StringArg.Value);
        }
    }
}

Editar: este es mi proyecto y, como tal, esta respuesta no debe verse como un respaldo de un tercero. Dicho esto, lo uso para cada programa basado en línea de comandos que escribo, es de código abierto y espero que otros se beneficien de él.


4
2018-01-23 16:55