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

Ответ 1

Я вижу много особенностей командной строки Windows, но если ваша программа предназначена для Linux, я нахожу стандарт командной строки GNU самый интуитивный. В основном, он использует двойные дефисы для длинной формы команды (например, --help) и один дефис для короткой версии (например, -h). Вы также можете "складывать" короткие версии вместе (например, tar -zxvf filename) и смешивать "n совпадение длинное и короткое с сердечным содержимым".

На сайте GNU также указаны стандартные имена опций.

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

Ответ 2

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

EDIT: Вот несколько функций

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

Ответ 3

Одна вещь, которая мне нравится в определенном CLI, - это использование ярлыков.
I.e, все следующие строки делают то же самое

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

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

Ответ 4

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

https://commandline.codeplex.com/

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

• Последняя стабильность: Install-Package CommandLineParser.
• Последняя версия: Install-Package CommandLineParser -pre.

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

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

Ответ 5

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

c:\>FOO

FOO

USAGE FOO -{Option}{Value}

-A Do A stuff
-B Do B stuff

c:\>

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

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

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

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

Ответ 6

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

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

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

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

Ответ 7

Соглашения с командной строкой варьируются от ОС к ОС, но соглашение, которое, вероятно, получило как наибольшее применение, так и самый публичный контроль, поддерживается протоколом GNU getopt. Для получения дополнительной информации см. http://www.gnu.org/software/libc/manual/html_node/Using-Getopt.html.

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

Ответ 8

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

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

Фактически, в этом случае я, вероятно, не принял бы аббревиатуру для "destroy"...

Ответ 9

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

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

Ответ 10

Я разработал эту структуру, возможно, это помогает:

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

Ответ 11

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

Например,

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

Ответ 12

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

Ответ 13

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

1) Какой тип приложения это.
2) Какую операционную систему вы используете. Linux? Окна? Они оба имеют разные соглашения.

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

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

Ответ 14

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

1) Какое приложение оно есть. 2) Какую операционную систему вы используете.

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

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

Параметры appName

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

Ответ 15

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

Ответ 16

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

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

Ответ 17

Я только что выпустил еще лучший синтаксический анализатор командной строки.
https://github.com/gene-l-thomas/coptions
Это на 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;
            }
        }
    }
}

Поддерживает автоматическое генерирование генерации, глаголы, например. commmand.exe
Наслаждайтесь.

Ответ 18

Я написал CLI-программу на C с GNU readline Libreary.. Посмотрите, поможет ли это Github: https://github.com/rrout/CLI