Suchen nach einem Befehlszeilenargument-Parser für .NET [geschlossen]

Ich suche nach einem Befehlszeilenargument-Parser wie "Befehlszeilen-Parser" von http://www.sellsbrothers.com/tools/Genghis/ .

Features, die ich suche:

• Automatische Generierung der Nutzung
• Sollte in der Lage sein, erforderliche und optionale Parameter zu überprüfen
• Die Parameter sollten IEnumerable mit Trennzeichen unterstützen
• Sollte Flag-Parameter unterstützen
• Wäre schön, das Kombinieren von Parametern wie "/ fx" == "/ f / x" zu unterstützen.
• Es wäre schön, nach einem Parameter wie "/ftest.txt" == "/ f test.txt" kein Leerzeichen zu erzwingen.

PS: "Command Line Parser" ist ziemlich gut, ich mag das Design sehr, aber es gibt keine Dokumentation, keine neuen Updates und ich konnte nicht herausfinden, wie man bestimmte Dinge erledigt, wie man nach erforderlichen Parametern sucht.

Meine persönliche Lieblings-Kommandozeilen-Parsing-Bibliothek von Drittanbietern ist Command Line Parser, und ich gehe davon aus, dass dies diejenige ist, auf die Sie sich beziehen. Die letzte Veröffentlichung war vor weniger als 2 Monaten und es gibt regelmäßige Commits. Wenn Sie ein ausgereifteres Angebot wünschen, können Sie die Konsolenbibliothek im Mono-Projekt durchsuchen (leider kann ich momentan keinen direkten Link zum Namespace finden, aber es ist Teil des Mono-Frameworks).

Schauen Sie sich ndesk.options an.

Es heißt jetzt Mono.Options .

Ein beliebter und ziemlich umfassender C-Befehlszeilenparser ist GNU getopt . Dies wurde mehrmals für C # /. Net portiert (oder geklont). Einige davon sind:

• getopt # auf freshmeat.net
• C # getopt bei PHPGuru
• XGetoptCS auf CodeProject
• GetOpt für .NET auf CodeProject
• Getopt C # .NET auf Codeplex

Treffen Sie Ihre Wahl! Es gibt mehrere andere, und Google kann Ihnen davon erzählen,

Leider gibt es keine eingebaute Unterstützung für die normale Handhabung. Haben Sie sich mit PowerShell befasst? Ich wette, es gibt eine Klasse in dieser Shell, die genau das tut, was Sie wollen oder ähnliches.

Bearbeiten: Wie fatcat1111 hervorhebt, wurde diese Funktion nicht mit der endgültigen Version von .net 4.0 ausgeliefert.

C # 4.0 hat eine ziemlich gute. Wahrscheinlich noch nicht sehr hilfreich, aber vielleicht möchten Sie sich etwas ansehen, das den Sprung zum eingebauten Gerät erleichtert, wenn es herauskommt. Bart De Smet hat in seinem B # -Blog darüber gesprochen

Ich schlage NDesk.Options vor

Schau hier:

Der beste Weg, um Befehlszeilenargumente in C # zu analysieren?

Bedenken Sie, dass Sie diesen Parser, sobald Sie ihn verwenden, entweder selbst warten müssen oder von jemand anderem abhängig sind, um ihn für Sie zu warten. Sie sind möglicherweise besser dran, Ihre eigenen zu schreiben, beginnend mit Ihren kritischsten, unmittelbarsten Anforderungen. Ich habe festgestellt, dass es nicht allzu viel Arbeit kostet, für die meisten konsolenbasierten Anwendungen, an denen ich gearbeitet habe, eine ziemlich komplizierte Befehlszeilenanalyse zu erstellen.

Ich habe auch festgestellt, dass es möglicherweise an der Zeit ist, die Befehlszeile nicht mehr zu verwenden, wenn das Parsen zu kompliziert wird.

Ich wette, das ist nicht ganz das, wonach Sie suchen, aber:

Jemand hier hatte dieses Problem, und sein erster Gedanke war "hey, ocaml hat einen ziemlich guten!" Und portierte ihn schnell auf F #.

Ich verwende den Parser aus dem C # 3.0-Kochbuch.

Alle Beispiele aus diesem Buch können hier heruntergeladen werden: http://examples.oreilly.com/9780596516109/

Suchen Sie nach "Argumente" und Sie werden es finden. Sie müssen einige kleine Codeänderungen vornehmen, um das Ganze in Ihre eigene Klasse zu bringen, aber das ist kein großes Problem.

Es unterstützt alle Ihre Punkte mit Ausnahme der letzten beiden (Parameter kombinieren & fehlender Platz).

Die BizArk-Bibliothek enthält einen Befehlszeilenparser.

Grundsätzlich erstellen Sie einfach eine Klasse, die von CmdLineObject erbt, fügen Eigenschaften hinzu, die über die Befehlszeile ausgefüllt werden sollen, fügen den Eigenschaften ein CmdLineArgAttribute hinzu und rufen dann Initialize in Ihrem Programm auf. Es unterstützt auch ClickOnce-URL-Argumente!

Funktionen (von der Website) ...

• Automatische Initialisierung: Klasseneigenschaften werden automatisch basierend auf den Befehlszeilenargumenten festgelegt.
• Standardeigenschaften: Senden Sie einen Wert ohne Angabe des Eigenschaftsnamens.
• Wertekonvertierung: Verwendet die leistungsstarke ConvertEx-Klasse, die auch in BizArk enthalten ist, um Werte in den richtigen Typ zu konvertieren.
• Boolesche Flags. Flags können durch einfaches Verwenden des Arguments (z. B. / b für true und / b- für false) oder durch Hinzufügen des Werts true / false, yes / no usw. angegeben werden.
• Argument-Arrays. Fügen Sie einfach mehrere Werte nach dem Befehlszeilennamen hinzu, 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 ganzen Zahlen definiert).
• Befehlszeilen-Aliase: Eine Eigenschaft kann mehrere Befehlszeilen-Aliase unterstützen. In der Hilfe wird beispielsweise der Alias? Verwendet.
• Teilweise Namenserkennung. 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 initialisieren, auch wenn sie als Abfragezeichenfolge in einer URL für von ClickOnce bereitgestellte Anwendungen angegeben sind. Die Befehlszeileninitialisierungsmethode erkennt, ob sie als ClickOnce ausgeführt wird oder nicht, sodass sich Ihr Code bei der Verwendung nicht ändern muss.
• Erstellt automatisch /? Hilfe: Dies beinhaltet eine nette Formatierung, die die Breite der Konsole berücksichtigt.
• Laden / Speichern von Befehlszeilenargumenten in eine Datei: Dies ist besonders nützlich, wenn Sie mehrere große, komplexe Sätze von Befehlszeilenargumenten haben, die Sie mehrmals ausführen möchten.

Ich bin ein Fan des C # -Ports für OptParse, eine in Python integrierte Bibliothek. Es ist im Vergleich zu den meisten anderen Vorschlägen hier recht einfach zu verwenden und enthält neben der automatischen Analyse eine Reihe nützlicher Funktionen.

Vielleicht gefällt dir mein einziger Rug.Cmd

Einfach zu verwendender und erweiterbarer Befehlszeilenargument-Parser. Handles: Bool, Plus / Minus, String, String-Liste, CSV, Aufzählung.

Eingebaut in '/?' Hilfemodus.

Eingebaut in '/ ??' und '/? D' Dokumentgenerator-Modi.

static void Main(string[] args) 
{            
    // create the argument parser
    ArgumentParser parser = new ArgumentParser("ArgumentExample", "Example of argument parsing");

    // create the argument for a string
    StringArgument StringArg = new StringArgument("String", "Example string argument", "This argument demonstrates string arguments");

    // add the argument to the parser 
    parser.Add("/", "String", StringArg);

    // parse arguemnts
    parser.Parse(args);

    // did the parser detect a /? argument 
    if (parser.HelpMode == false) 
    {
        // was the string argument defined 
        if (StringArg.Defined == true)
        {
            // write its value
            RC.WriteLine("String argument was defined");
            RC.WriteLine(StringArg.Value);
        }
    }
}

Bearbeiten: Dies ist mein Projekt und als solches sollte diese Antwort nicht als Bestätigung durch einen Dritten angesehen werden. Das heißt, ich benutze es für jedes Kommandozeilen-basierte Programm, das ich schreibe, es ist Open Source und ich hoffe, dass andere davon profitieren können.