command-line - sirve - linea de comandos concepto

Sugerencias para la implementación de una interfaz de línea de comando

Question

Estoy rediseñando una aplicación de línea de comandos y estoy buscando una manera de hacer que su uso sea más intuitivo. ¿Hay alguna convención para el formato de los parámetros pasados ​​a una aplicación de línea de comando? ¿O cualquier otro método que las personas hayan encontrado útil?

Answer 1

Las convenciones que use para su aplicación dependerán de

1) ¿Qué tipo de aplicación es? 2) Qué sistema operativo estás usando.

Esto es definitivamente cierto. No estoy seguro acerca de las convenciones de dos indicaciones, pero en sistemas tipo Unix, las convenciones generales son más o menos:

1) El formateo es

parámetros de appName

2) Los parámetros de un solo carácter (como ''x'') se pasan como -x 3) Los parámetros de múltiples caracteres (como ''add-keys'') se pasan como --add-keys

Answer 2

-operation [parameters] -command [your command] -anotherings [otherparams] ....

Por ejemplo,

YourApp.exe -file %YourProject.prj% -Secure true

Answer 3

Acabo de lanzar un analizador de línea de comando incluso mejor.
https://github.com/gene-l-thomas/coptions
Está en Nuget Install-Package coptions

using System;
using System.Collections.Generic;
using coptions;

[ApplicationInfo(Help = "This program does something useful.")]
public class Options
{
    [Flag(''s'', "silent", Help = "Produce no output.")]
    public bool Silent;

    [Option(''n'', "name", "NAME", Help = "Name of user.")]
    public string Name
    {
        get { return _name;  }
        set { if (String.IsNullOrWhiteSpace(value))
                throw new InvalidOptionValueException("Name must not be blank");
              _name = value;
        }
    }
    private string _name;

    [Option("size", Help = "Size to output.")]
    public int Size = 3;

    [Option(''i'', "ignore", "FILENAME", Help = "Files to ignore.")]
    public List<string> Ignore;

    [Flag(''v'', "verbose", Help = "Increase the amount of output.")]
    public int Verbose = 1;

    [Value("OUT", Help = "Output file.")]
    public string OutputFile;

    [Value("INPUT", Help = "Input files.")]
    public List<string> InputFiles;
}

namespace coptions.ReadmeExample
{
    class Program
    {
        static int Main(string[] args)
        {
            try
            {
                Options opt = CliParser.Parse<Options>(args);

                Console.WriteLine(opt.Silent);
                Console.WriteLine(opt.OutputFile);
                return 0;
            }
            catch (CliParserExit)
            {
                // --help
                return 0;

            } catch (Exception e)
            {
                // unknown options etc...
                Console.Error.WriteLine("Fatal Error: " + e.Message);
                return 1;
            }
        }
    }
}

Admite generación automática de ayuda, verbos, por ejemplo, commmand.exe
Disfrutar.

Answer 4

Aquí hay un artículo de CodeProject que podría ayudarte ...

Analizador de argumentos de la línea de comandos C # / .NET

SI VB es tu sabor, aquí hay un artículo separado (con un poco más de contenido relacionado con la orientación) para ver ...

Analizar y validar los parámetros de la línea de comando con VB.NET

Answer 5

Complementando la respuesta de @ vonc, no acepte abreviaturas ambiguas. P.ej:

  myCli.exe describe someThing
  myCli.exe destroy someThing
  myCli.exe des someThing ???

De hecho, en ese caso, probablemente no aceptaría una abreviatura para "destruir" ...

Answer 6

Creé una biblioteca .Net C # que incluye un analizador de línea de comandos. Solo necesita crear una clase que herede de la clase CmdLineObject, invocar Inicializar y completará automáticamente las propiedades. Puede manejar conversiones a diferentes tipos (utiliza una biblioteca de conversión avanzada también incluida en el proyecto), matrices, alias de línea de comandos, argumentos de una sola pulsación, etc. Incluso crea automáticamente la ayuda de línea de comandos (/?).

Si está interesado, la URL del proyecto es http://bizark.codeplex.com . Actualmente solo está disponible como código fuente.

Answer 7

Las convenciones de línea de comandos varían de sistema operativo a sistema operativo, pero la convención que probablemente haya obtenido el mayor uso, y el escrutinio más público es el que admite el paquete getopt de GNU. Consulte para obtener más información.

Le permite mezclar comandos de una sola letra, como -nr, con opciones de auto-documentación más largas, como --numeral --reverse. Sea amable e implemente una opción --help (-?) Y luego sus usuarios podrán descubrir todo lo que necesitan saber.

Answer 8

Las convenciones que use para su aplicación dependerán de

1) ¿Qué tipo de aplicación es?
2) Qué sistema operativo estás usando. Linux? Windows? Ambos tienen diferentes convenciones.

Lo que sugeriría es mirar otras interfaces de línea de comando para otros comandos en su sistema, prestando especial atención a los parámetros aprobados. Tener parámetros incorrectos debería dar al usuario un mensaje de error dirigido a la solución. Una pantalla de ayuda fácil de encontrar también puede ayudar a la usabilidad.

Sin saber exactamente qué hará su aplicación, es difícil dar ejemplos específicos.

Answer 9

Lo mejor que puedes hacer es no asumir nada si puedes. Cuando el operador escriba el nombre de su aplicación para la ejecución y no tenga ningún parámetro, acéptelos con un bloque de USO o, como alternativa, abra un Formulario de Windows y permita que ingresen todo lo que necesita.

c:/>FOO

FOO

USAGE FOO -{Option}{Value}

-A Do A stuff
-B Do B stuff

c:/>

La delimitación de parámetros la ubico bajo el encabezado de un tema religioso: guiones (guiones), guiones dobles, barras, nada, posicional, etc.

No indicó su plataforma, pero para el próximo comentario asumiré Windows y .net

Puede crear una aplicación basada en consola en .net y permitirle interactuar con el Escritorio usando Formularios simplemente eligiendo el proyecto basado en la consola y luego agregando los archivos DLL Windows.Forms, System.Drawing, etc.

Hacemos esto todo el tiempo. Esto asegura que nadie da una vuelta por un callejón oscuro.

Answer 10

Si está usando C # intente Mono.GetOptions , es un analizador de argumentos de línea de comandos muy poderoso y fácil de usar. Funciona en entornos Mono y con Microsoft .NET Framework.

EDITAR: Aquí hay algunas características

• Cada parámetro tiene 2 representaciones CLI (1 carácter y cadena, por ejemplo, -a o --add)
• Valores predeterminados
• Fuertemente tipado
• Automáticamente produce una pantalla de ayuda con instrucciones
• Automáticamente produce una versión y pantalla de copyright

Answer 11

Si está utilizando Perl, mi CLI::Application Framework podría ser justo lo que necesita. Le permite crear aplicaciones con una interfaz de usuario SVN / CVS / GIT fácilmente ("your-command -o --long-opt-some-action-to-execute").

Answer 12

Si usa una de las herramientas estándar para generar interfaces de línea de comando, como getopts, entonces se conformará automáticamente.

Answer 13

Siempre agrego a /? parámetro para obtener ayuda y siempre trato de tener una implementación predeterminada (es decir, el escenario más común).

De lo contrario, tiendo a usar el "/ x" para los interruptores y "/ x: valor" para los interruptores que requieren que se pasen los valores. Hace que sea muy fácil analizar los parámetros usando expresiones regulares.

Answer 14

Una buena y útil referencia:

https://commandline.codeplex.com/

Biblioteca disponible a través de NuGet:

1. Última estabilidad: Install-Package CommandLineParser .
2. Última versión: Install-Package CommandLineParser -pre .

Análisis de una línea utilizando singleton predeterminado: CommandLine.Parser.Default.ParseArguments(...) .
Generador de pantalla de ayuda de una línea: HelpText.AutoBuild(...) .
Asigne los argumentos de línea de comando a IList<string> , arrays, enum o tipos escalares estándar.
Arquitectura amigable de plug-in como se explica aquí.
Defina los comandos verbales como git commit -a .
Crea una instancia del analizador usando expresiones lambda.

QuickStart: https://commandline.codeplex.com/wikipage?title=Quickstart&referringTitle=Documentation

// Define a class to receive parsed values
class Options {
  [Option(''r'', "read", Required = true,
    HelpText = "Input file to be processed.")]
  public string InputFile { get; set; }

  [Option(''v'', "verbose", DefaultValue = true,
    HelpText = "Prints all messages to standard output.")]
  public bool Verbose { get; set; }

  [ParserState]
  public IParserState LastParserState { get; set; }

  [HelpOption]
  public string GetUsage() {
    return HelpText.AutoBuild(this,
      (HelpText current) => HelpText.DefaultParsingErrorsHandler(this, current));
  }
}

// Consume them
static void Main(string[] args) {
  var options = new Options();
  if (CommandLine.Parser.Default.ParseArguments(args, options)) {
    // Values are available here
    if (options.Verbose) Console.WriteLine("Filename: {0}", options.InputFile);
  }
}

Answer 15

Una cosa que me gusta de cierta CLI es el uso de accesos directos .
Es decir, todas las siguientes líneas están haciendo lo mismo

myCli.exe describe someThing
myCli.exe descr someThing
myCli.exe desc someThing

De esta forma, el usuario puede no tener que escribir todos los comandos todo el tiempo.

Answer 16

Desarrollé este marco, tal vez ayuda:

SysCommand es un potente marco de trabajo multiplataforma para desarrollar aplicaciones de consola en .NET. Es simple, seguro para tipos, y con grandes influencias del patrón MVC.

https://github.com/juniorgasparotto/SysCommand

namespace Example.Initialization.Simple
{
    using SysCommand.ConsoleApp;

    public class Program
    {
        public static int Main(string[] args)
        {
            return App.RunApplication();
        }
    }

    // Classes inheriting from `Command` will be automatically found by the system
    // and its public properties and methods will be available for use.
    public class MyCommand : Command
    {
        public void Main(string arg1, int? arg2 = null)
        {
            if (arg1 != null)
                this.App.Console.Write(string.Format("Main arg1=''{0}''", arg1));
            if (arg2 != null)
                this.App.Console.Write(string.Format("Main arg2=''{0}''", arg2));
        }

        public void MyAction(bool a)
        {
            this.App.Console.Write(string.Format("MyAction a=''{0}''", a));
        }
    }
}

Pruebas:

// auto-generate help
$ my-app.exe help

// method "Main" typed
$ my-app.exe --arg1 value --arg2 1000

// or without "--arg2"
$ my-app.exe --arg1 value

// actions support
$ my-app.exe my-action -a

Answer 17

Veo muchos detalles de la línea de comandos de Windows, pero si su programa está destinado a Linux, creo que el estándar de línea de comandos de GNU es el más intuitivo. Básicamente, utiliza guiones dobles para la forma larga de un comando (por ejemplo, --help ) y un único guión para la versión corta (por ejemplo, -h ). También puede "apilar" las versiones cortas juntas (p. Ej., tar -zxvf filename tar -zxvf ) y mezclar ''n coincide con lo largo y lo corto para el contenido de su corazón.

El sitio de GNU también enumera nombres de opciones estándar .

La biblioteca getopt simplifica enormemente el análisis de estos comandos. Si C no es tu cartera, Python tiene una biblioteca similar, al igual que Perl .