Sugestie dotyczące implementacji interfejsu wiersza poleceń

Jeśli używasz C# spróbuj Mono.GetOptions , jest bardzo wydajnym i prostym w użyciu parserem argumentów wiersza poleceń. Działa w środowiskach Mono oraz z Microsoft. NET Framework.

EDIT: Oto kilka funkcji

• Każdy param ma 2 reprezentacje CLI (1 znak i łańcuch, np.-A lub --add)
• wartości domyślne
• mocno wpisane
• Automatycznie tworzy ekran pomocy z instrukcjami
• automagicznie produkuje wersję i copyright screen

Jedną z rzeczy, które lubię w niektórych CLI, jest użycie skrótów .
Oznacza to, że wszystkie następujące linie robią to samo

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

W ten sposób użytkownik nie będzie musiał za każdym razem wpisywać polecenia all.

Dobre i pomocne odniesienie:

Https://commandline.codeplex.com/

Biblioteka dostępna przez NuGet:

1. Ostatnia stajnia: Install-Package CommandLineParser.
2. najnowsze wydanie: Install-Package CommandLineParser -pre.

Parsowanie jednej linii przy użyciu domyślnego Singletona: CommandLine.Parser.Default.ParseArguments(...).
One line help screen generator: HelpText.AutoBuild(...).
Mapuje argumenty linii poleceń na IList<string>, tablice, enum lub standardowe typy skalarne.
Architektura przyjazna wtyczkom, jak wyjaśniono tutaj.
Definiowanie poleceń czasownika jako git commit -a.
Utwórz instancję parsera używając wyrażeń 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);
  }
}

Najlepszą rzeczą do zrobienia jest nie zakładać niczego, jeśli możesz. Gdy operator wpisuje nazwę Twojej aplikacji do wykonania i nie ma żadnych parametrów, albo naciśnij je blokiem użycia lub w alternatywnym otwórz formularz Windows i pozwól im wprowadzić wszystko, czego potrzebujesz.

c:\>FOO

FOO

USAGE FOO -{Option}{Value}

-A Do A stuff
-B Do B stuff

c:\>

Parametr rozgraniczający umieszczam pod nagłówkiem tematu religijnego: myślniki (myślniki), podwójne myślniki, ukośniki, nic, pozycyjne itp.

Nie wskazałeś swojej platformy, ale na następny komentarz przyjmę Windows i. Net

Możesz utworzyć aplikację opartą na konsoli w. Net i zezwolić jej na interakcję z pulpitem za pomocą formularzy, wybierając projekt oparty na konsoli, a następnie dodając okna.Formularze, System.Rysowanie itp.

Konwencje wiersza poleceń różnią się w zależności od systemu operacyjnego, ale konwencja, która prawdopodobnie zyskała zarówno największe zastosowanie, jak i najbardziej publiczną kontrolę, jest tą wspieraną przez pakiet GNU getopt. Zobacz też http://www.gnu.org/software/libc/manual/html_node/Using-Getopt.html aby uzyskać więcej informacji.

Pozwala na mieszanie pojedynczych poleceń, takich jak-nr, z dłuższymi, samodokumentującymi się opcjami, takimi jak --numeric --reverse. Bądź miły i ... pomóż (-?) opcja, a następnie twój użytkownicy będą mogli dowiedzieć się wszystkiego, co muszą wiedzieć.

Oto artykuł CodeProject, który może Ci pomóc...

Parser argumentów linii poleceń C#/. Net

Jeśli VB jest Twoim smakiem, oto osobny artykuł (z nieco większą zawartością związaną z poradnikami) do sprawdzenia...

Parse and Validate Command Line Parameters with VB.NET

Uzupełniając odpowiedź @vonc, nie przyjmuj dwuznacznych skrótów. Eg:

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

W rzeczywistości, w takim przypadku, prawdopodobnie nie zaakceptowałbym skrótu "zniszczyć"...

Zawsze dodaję/? parametr, aby uzyskać pomoc i zawsze staram się mieć domyślną (tj. najczęściej scenariusz) implementację.

W przeciwnym razie zwykle używam " / x "dla przełączników i" /X:value " dla przełączników, które wymagają podania wartości. Ułatwia analizę parametrów za pomocą wyrażeń regularnych.

Opracowałem ten framework, może pomoże:

SysCommand jest potężnym wieloplatformowym frameworkiem do tworzenia aplikacji konsolowych w .NET. jest prosty, bezpieczny dla typu i ma wielkie wpływy wzorca 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));
        }
    }
}

Testy:

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

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

Na przykład,

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

Jeśli używasz jednego ze standardowych narzędzi do generowania interfejsów linii poleceń, takich jak getopts, to będziesz się dostosowywał automatycznie.

Konwencje, których używasz w swojej aplikacji, zależą od

1) jaki to rodzaj aplikacji. 2) jakiego systemu operacyjnego używasz.

1) formatowanie to

Parametry AppName

2) Parametry pojedynczego znaku (takie jak 'x') są przekazywane jako-x 3) Multi parametry znaków (takie jak 'add-keys') są przekazywane jako --add-keys

Konwencje, których używasz w swojej aplikacji, zależą od

1) jaki to rodzaj aplikacji.
2) jakiego systemu operacyjnego używasz. Linux? Okna? Obie mają różne konwencje.

To, co sugerowałbym, to spojrzenie na inne Interfejsy wiersza poleceń dla innych poleceń w systemie, zwracając szczególną uwagę na przekazywane parametry. Posiadanie nieprawidłowych parametrów powinno dać użytkownikowi komunikat o błędzie skierowany do rozwiązania. Łatwy do znalezienia ekran pomocy może pomoc również w użyteczności.

Bez wiedzy, co dokładnie zrobi Twoja aplikacja, trudno podać konkretne przykłady.

Jeśli używasz Perla, mój Cli::Application framework może być właśnie tym, czego potrzebujesz. Pozwala na łatwe tworzenie aplikacji z interfejsem SVN / CVs / GIT ("your-command-o --long-opt some-action-to-execute some parameters").

Stworzyłem bibliotekę. Net C#, która zawiera parser wiersza poleceń. Wystarczy utworzyć klasę, która dziedziczy z klasy CmdLineObject, wywołać Initialize, a to automatycznie wypełni właściwości. Może obsługiwać konwersje do różnych typów (wykorzystuje zaawansowaną bibliotekę konwersji dołączoną do projektu), tablic, aliasów wiersza poleceń, argumentów click-once, itp. Nawet automatycznie tworzy pomoc wiersza poleceń ( / ?).

Jeśli jesteś zainteresowany, adres URL do projekt jest http://bizark.codeplex.com . obecnie jest dostępny tylko jako kod źródłowy.

Właśnie wypuściłem jeszcze lepszy parser wiersza poleceń.
https://github.com/gene-l-thomas/coptions
Jest na 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;
            }
        }
    }
}

Obsługuje automatyczne generowanie -- help, czasowników, np. commmand.exe
Smacznego.