Beste Weg, um Befehlszeilenargumente in C# zu parsen?

Question

Wenn Sie Konsolenanwendungen erstellen, die Parameter benötigen, können Sie die Argumente verwenden, die an Main(string[] args) .

In der Vergangenheit habe ich einfach indiziert/geschleift, dass Array und tat ein paar reguläre Ausdrücke, um die Werte zu extrahieren. Wenn die Befehle jedoch komplizierter werden, kann das Parsing ziemlich unschön werden.

Ich bin also interessiert:

• Bibliotheken, die Sie verwenden
• Muster, die Sie verwenden

Gehen Sie davon aus, dass sich die Befehle immer an gemeinsame Standards halten, wie z. B. hier beantwortet .

Answer 1

Ich würde dringend empfehlen, Folgendes zu verwenden NDesk.Optionen ( Dokumentation ) und/oder Mono.Optionen (gleiche API, anderer Namensraum). Eine Beispiel aus der Dokumentation :

bool show_help = false;
List<string> names = new List<string> ();
int repeat = 1;

var p = new OptionSet () {
    { "n|name=", "the {NAME} of someone to greet.",
       v => names.Add (v) },
    { "r|repeat=", 
       "the number of {TIMES} to repeat the greeting.\n" + 
          "this must be an integer.",
        (int v) => repeat = v },
    { "v", "increase debug message verbosity",
       v => { if (v != null) ++verbosity; } },
    { "h|help",  "show this message and exit", 
       v => show_help = v != null },
};

List<string> extra;
try {
    extra = p.Parse (args);
}
catch (OptionException e) {
    Console.Write ("greet: ");
    Console.WriteLine (e.Message);
    Console.WriteLine ("Try `greet --help' for more information.");
    return;
}

Answer 2

Besonders gut gefällt mir die Command Line Parser Library ( http://commandline.codeplex.com/ ). Es bietet eine sehr einfache und elegante Möglichkeit, Parameter über Attribute einzurichten:

class Options
{
    [Option("i", "input", Required = true, HelpText = "Input file to read.")]
    public string InputFile { get; set; }

    [Option(null, "length", HelpText = "The maximum number of bytes to process.")]
    public int MaximumLenght { get; set; }

    [Option("v", null, HelpText = "Print details during execution.")]
    public bool Verbose { get; set; }

    [HelpOption(HelpText = "Display this help screen.")]
    public string GetUsage()
    {
        var usage = new StringBuilder();
        usage.AppendLine("Quickstart Application 1.0");
        usage.AppendLine("Read user manual for usage instructions...");
        return usage.ToString();
    }
}

Answer 3

El WPF TestApi-Bibliothek wird mit einem der besten Kommandozeilen-Parser für die C#-Entwicklung geliefert. Ich empfehle dringend einen Blick darauf zu werfen, von Ivo Manolovs Blog über die API :

// EXAMPLE #2:
// Sample for parsing the following command-line:
// Test.exe /verbose /runId=10
// This sample declares a class in which the strongly-
// typed arguments are populated
public class CommandLineArguments
{
   bool? Verbose { get; set; }
   int? RunId { get; set; }
}

CommandLineArguments a = new CommandLineArguments();
CommandLineParser.ParseArguments(args, a);

Answer 4

Blick auf http://github.com/mono/mono/tree/master/mcs/class/Mono.Options/

Answer 5

Wie es aussieht, hat jeder seine eigenen Lieblings-Befehlszeilen-Parser, also sollte ich meinen auch hinzufügen :).

http://bizark.codeplex.com/

Diese Bibliothek enthält eine Kommandozeilen-Parser die eine Klasse mit den Werten aus der Befehlszeile initialisiert. Es hat eine Vielzahl von Funktionen (ich habe es über viele Jahre hinweg aufgebaut).

Von der Dokumentation ...

Das Kommandozeilen-Parsing im BizArk-Framework hat folgende Hauptmerkmale:

• Automatische Initialisierung: Die Klasseneigenschaften werden automatisch auf der Grundlage der Befehlszeilenargumente festgelegt.
• Standard-Eigenschaften: Senden Sie einen Wert ohne Angabe des Eigenschaftsnamens.
• Wertumwandlung: Verwendet die leistungsstarke ConvertEx-Klasse, die auch in BizArk enthalten ist, um Werte in den richtigen Typ zu konvertieren.
• Boolesche Flaggen: Flags können einfach durch die Verwendung des Arguments (z. B. /b für true und /b- für false) oder durch Hinzufügen der Werte true/false, yes/no usw. angegeben werden.
• Argument-Arrays: Fügen Sie einfach mehrere Werte nach dem Befehlszeilennamen ein, um eine Eigenschaft festzulegen, die als Array definiert ist. Beispiel: /x 1 2 3 füllt x mit dem Array { 1, 2, 3 } (vorausgesetzt, x ist als Array von Ganzzahlen definiert).
• Kommandozeilen-Aliase: Eine Eigenschaft kann mehrere Befehlszeilen-Aliase für sie unterstützen. Zum Beispiel verwendet Help den Alias ?.
• Teilweiser Bekanntheitsgrad: Sie müssen nicht den vollständigen Namen oder Alias buchstabieren, sondern nur so viel, dass der Parser die Eigenschaft/den Alias von den anderen unterscheiden kann.
• Unterstützt ClickOnce: Kann Eigenschaften auch dann initialisieren, wenn sie als Abfragezeichenfolge in einer URL für mit ClickOnce bereitgestellte Anwendungen angegeben sind. Die Befehlszeilen-Initialisierungsmethode erkennt, ob sie als ClickOnce ausgeführt wird oder nicht, sodass Ihr Code nicht geändert werden muss, wenn Sie sie verwenden.
• Erzeugt automatisch /? Hilfe: Dazu gehört eine schöne Formatierung, die die Breite der Konsole berücksichtigt.
• Laden/Speichern von Kommandozeilenargumenten in eine Datei: Dies ist besonders nützlich, wenn Sie mehrere große, komplexe Sätze von Befehlszeilenargumenten haben, die Sie mehrfach ausführen wollen.