Предложения по реализации интерфейса командной строки

-операция [параметры] -команда [ваша команда] -другие [другие параметры] ....

Например,

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

Если вы используете C#, попробуйте Mono.GetOptions, это очень мощный и простой в использовании синтаксический анализатор аргументов командной строки. Он работает в средах Mono и с Microsoft .NET Framework.

Обновлено: вот несколько функций

• Каждый параметр имеет 2 представления CLI (1 символ и строка, например -a или --add)
• Значения по умолчанию
• Строго типизированный
• Автоматически создает экран справки с инструкциями
• Автоматически создает экран версии и авторских прав

Если вы используете один из стандартных инструментов для генерации интерфейсов командной строки, например getopts, то вы согласитесь автоматически.

Лучше всего ничего не предполагать, если можете. Когда оператор вводит имя вашего приложения для выполнения и не имеет каких-либо параметров, либо нажмите им блоком USAGE, либо, в качестве альтернативы, откройте форму Windows и разрешите им ввести все, что вам нужно.

c:\>FOO

FOO

USAGE FOO -{Option}{Value}

-A Do A stuff
-B Do B stuff

c:\>

Параметр-разделитель помещаю под заголовком религиозной темы: дефисы (тире), двойные дефисы, косые черты, ничего, позиционное и т. д.

Вы не указали свою платформу, но в следующем комментарии я предполагаю, что Windows и .net

Вы можете создать консольное приложение в .net и разрешить ему взаимодействовать с рабочим столом с помощью форм, просто выбрав консольный проект, а затем добавив библиотеки DLL Windows.Forms, System.Drawing и т. д.

Мы делаем это постоянно. Это гарантирует, что никто не свернет в темный переулок.

Я всегда добавляю /? параметр, чтобы получить помощь, и я всегда стараюсь иметь реализацию по умолчанию (т.е. наиболее распространенный сценарий).

В противном случае я предпочитаю использовать «/ x» для переключателей и «/ x: value» для переключателей, которые требуют передачи значений. Упрощает анализ параметров с помощью регулярных выражений.

Соглашения, которые вы используете для своего приложения, будут зависеть от

1) Что это за тип приложения.
2) Какую операционную систему вы используете. Linux? Windows? У них обоих разные условности.

Я бы посоветовал взглянуть на другие интерфейсы командной строки для других команд в вашей системе, уделяя особое внимание передаваемым параметрам. При неправильных параметрах пользовательское решение должно выдавать сообщение об ошибке. Легко найти экран справки также может помочь в удобстве использования.

Не зная, что именно будет делать ваше приложение, сложно привести конкретные примеры.

Что мне нравится в некоторых интерфейсах командной строки, так это использование ярлыки.
. То есть все следующие строки делают то же самое

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

Таким образом, пользователю не придется каждый раз вводить команду all.

Вот статья CodeProject, которая может вам помочь ...

Синтаксический анализатор аргументов командной строки C# /. NET

ЕСЛИ VB - ваш вкус, вот отдельная статья (с немного большим содержанием, связанным с инструкциями), чтобы проверить ...

Анализ и проверка параметров командной строки с помощью VB.NET

The conventions that you use for you application would depend on

1) What type of application it is. 2) What operating system you are using.

Это определенно правда. Я не уверен в соглашениях с dos-prompt, но в unix-подобных системах общие соглашения примерно такие:

1) Форматирование

appName parameters

2) Односимвольные параметры (например, 'x') передаются как -x 3) Многосимвольные параметры (такие как 'add-keys') передаются как --add-keys.

Command line conventions vary from OS to OS, but the convention that's probably gotten both the most use, and the most public scrutiny is the one supported by the GNU getopt package. See http://www.gnu.org/software/libc/manual/html_node/Using-Getopt.html для получения дополнительной информации.

Он позволяет сочетать однобуквенные команды, такие как -nr, с более длинными, самодокументированными параметрами, такими как --numeric --reverse. Будьте любезны и реализуйте опцию --help (-?), И тогда ваши пользователи смогут выяснить все, что им нужно знать.

Дополняя ответ @vonc, не принимайте двусмысленные сокращения. Например:

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

На самом деле, в этом случае я бы, вероятно, не принял аббревиатуру «уничтожить» ...

Я вижу много особенностей командной строки Windows, но если ваша программа предназначена для Linux, я считаю Стандарт командной строки GNU наиболее интуитивно понятным. По сути, он использует двойные дефисы для длинной формы команды (например, --help) и одиночный дефис для короткой версии (например, -h). Вы также можете «сложить» короткие версии вместе (например, tar -zxvffilename) и смешать длинные и короткие версии, сколько душе угодно.

На сайте GNU также есть список стандартные названия опций.

библиотека getopt значительно упрощает синтаксический анализ этих команд. Если C - не ваша сумка, Python имеет аналогичную библиотеку, как и Perl.

Если вы используете Perl, мой фреймворк CLI :: Приложение может быть именно тем, что вам нужно. Он позволяет вам легко создавать приложения с пользовательским интерфейсом, подобным SVN / CVS / GIT ("your-command -o --long-opt some-action-to-execute some parameters").

Я создал библиотеку .Net C#, которая включает синтаксический анализатор командной строки. Вам просто нужно создать класс, наследующий от класса CmdLineObject, вызвать Initialize, и он автоматически заполнит свойства. Он может обрабатывать преобразования в различные типы (использует расширенную библиотеку преобразования, также включенную в проект), массивы, псевдонимы командной строки, аргументы однократного щелчка и т. д. Он даже автоматически создает справку командной строки (/?).

Если вам интересно, URL-адрес проекта - http://bizark.codeplex.com. В настоящее время он доступен только в виде исходного кода.

Хорошая и полезная ссылка:

https://commandline.codeplex.com/

Библиотека, доступная через NuGet:

1. Последняя стабильная версия: Install-Package CommandLineParser.
2. Последний выпуск: Install-Package CommandLineParser -pre.

Разбор одной строки с использованием синглтона по умолчанию: CommandLine.Parser.Default.ParseArguments(...).
Генератор однострочного экрана справки: HelpText.AutoBuild(...).
Сопоставьте аргументы командной строки с IList<string>, массивами, перечислениями или стандартными скалярными типами. Дружественная к плагинам архитектура, как описано здесь. Определите команды глагола как git commit -a.
Создайте экземпляр парсера, используя лямбда-выражения.

Быстрый запуск: 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);
  }
}

Я разработал этот фреймворк, может, это поможет:

SysCommand - это мощный кроссплатформенный фреймворк для разработки консольных приложений в .NET. Он прост, безопасен в отношении типов и имеет большое влияние на шаблон 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));
        }
    }
}

Тесты:

// 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

Я только что выпустил еще более совершенный парсер командной строки. https://github.com/gene-l-thomas/coptions
Это на nuget Установочные пакеты

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;
            }
        }
    }
}

Поддерживает автоматическое создание --help, глаголов, например. commmand.exe
Наслаждаться.