Buscando un analizador de argumentos de línea de comandos para .NET [cerrado]

Estoy buscando un analizador de argumentos de línea de comandos, como "Analizador de línea de comandos" de http://www.sellsbrothers.com/tools/Genghis/ .

Características que estoy buscando:

• Autogeneración de uso
• Debería poder verificar los parámetros obligatorios y opcionales
• Los parámetros deben admitir IEnumerable con compatibilidad con separadores
• Debe admitir parámetros de bandera
• Sería bueno admitir la combinación de parámetros como "/ fx" == "/ f / x"
• Sería bueno no forzar un espacio después de un parámetro como "/ftest.txt" == "/ f test.txt"

PD: "Analizador de línea de comandos" es bastante bueno, me gusta mucho el diseño, pero no hay documentación, no hay nuevas actualizaciones y no pude hacer ciertas cosas, como comprobar los parámetros necesarios.

Mi biblioteca de análisis de línea de comandos de terceros favorita es el analizador de línea de comandos y supongo que es a la que se refiere. El lanzamiento más reciente fue hace menos de 2 meses y hay confirmaciones regulares. Si desea una oferta más madura, puede verificar la biblioteca de la consola en el proyecto mono (lo siento, parece que no puedo encontrar un enlace directo al espacio de nombres en este momento, pero es parte del marco mono)

Eche un vistazo a ndesk.options.

Ahora se llama Mono.Options .

Un analizador de línea de comandos de C popular y bastante completo es GNU getopt . Esto se ha portado (o clonado) para C # /. Net varias veces. Algunos de estos incluyen:

• getopt # en freshmeat.net
• C # getopt en PHPGuru
• XGetoptCS en CodeProject
• GetOpt para .NET en CodeProject
• Getopt C # .NET en Codeplex

¡Elige tu opción! Hay varios otros, y Google puede informarle sobre ellos,

Lamentablemente, no hay soporte integrado para manejar eso de manera estándar. ¿Ha mirado PowerShell? Apuesto a que hay una clase en ese caparazón que hace exactamente lo que quieres o algo similar.

Edición: como señala fatcat1111, esta función no se incluyó con la versión final de .net 4.0.

C # 4.0 tiene uno bastante bueno. Probablemente no sea muy útil todavía, pero es posible que desee considerar buscar algo que haga que el salto al sistema integrado sea fácil cuando salga. Bart De Smet habló de ello en su blog B #

Sugiero NDesk.Options

mira aquí:

¿La mejor manera de analizar los argumentos de la línea de comando en C #?

Tenga en cuenta que una vez que comience a usar este analizador, tendrá que mantenerlo usted mismo o depender de otra persona para que lo mantenga por usted. Puede que sea mejor que escriba el suyo, comenzando por sus requisitos más críticos e inmediatos. Descubrí que no se necesita mucho trabajo para producir un análisis de línea de comandos bastante complicado para la mayoría de las aplicaciones basadas en consola en las que he trabajado.

También descubrí que cuando el análisis se vuelve demasiado complicado, puede ser el momento de dejar de usar la línea de comandos.

Apuesto a que esto no es exactamente lo que estás buscando, pero:

Alguien aquí tenía ese problema, y ​​su primer pensamiento fue "¡oye, ocaml tiene uno bastante bueno!", Y rápidamente lo transfirió a F #.

Estoy usando el analizador del libro de cocina de C # 3.0.

Todos los ejemplos de este libro se pueden descargar aquí: http://examples.oreilly.com/9780596516109/

Busque 'Argumentos' y lo encontrará. Tienes que hacer algunos pequeños cambios de código para sacarlo de todo en tu propia clase, pero esto no es un gran problema.

Es compatible con todos sus puntos excepto los dos últimos (combinación de parámetros y espacio faltante).

La biblioteca de BizArk contiene un analizador de línea de comandos.

Básicamente, solo crea una clase que hereda de CmdLineObject, agrega las propiedades que desea que se completen desde la línea de comandos, agrega un CmdLineArgAttribute a las propiedades y luego llama a Initialize en su programa. ¡También admite argumentos de URL ClickOnce!

Características (del sitio) ...

• Inicialización automática: las propiedades de la 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 adecuado.
• Banderas booleanas. Las banderas se pueden especificar simplemente usando el argumento (por ejemplo, / b para verdadero y / b- para falso) o agregando el valor verdadero / falso, sí / no, etc.
• Matrices de argumentos. Simplemente agregue varios valores después del nombre de la línea de comandos para establecer una propiedad que se define como una matriz. Por ejemplo, / x 1 2 3 completará x con la matriz {1, 2, 3} (asumiendo que x se define como una matriz de números enteros).
• Alias ​​de la línea de comandos: una propiedad puede admitir varios alias de la línea de comandos. Por ejemplo, Help usa el alias ?.
• Reconocimiento parcial de nombres. No es necesario que deletree el nombre completo o el alias, solo deletree lo suficiente para que el analizador distinga 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 las aplicaciones implementadas de 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 su código no necesita cambiar al usarlo.
• Crea automáticamente /? ayuda: Esto incluye un formato agradable 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 varios conjuntos grandes y complejos de argumentos de línea de comandos que desea ejecutar varias veces.

Soy fanático del puerto C # para OptParse, una biblioteca integrada en Python. Es bastante simple de usar en comparación con la mayoría de las otras sugerencias aquí y contiene una serie de funciones útiles además del análisis automático.

Puede que te guste mi única alfombra.Cmd

Analizador de argumentos de línea de comandos fácil de usar y expandible. Maneja: Bool, Más / Menos, Cadena, Lista de cadenas, CSV, Enumeración.

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 todos los programas basados ​​en líneas de comandos que escribo, es de código abierto y espero que otros se beneficien de él.