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

Es gibt einen Parser für Kommandozeilenargumente unter http://www.codeplex.com/commonlibrarynet

Er kann Argumente analysieren, indem er
1. Eigenschaften
2. explizite Anrufe
3. einzelne Zeile mit mehreren Argumenten ODER String-Array

Es kann unter anderem folgende Aufgaben übernehmen:

- Konfiguration :Qa - Startdatum :${ heute } - Region :'New York' Einstellungen01

Es ist sehr einfach zu bedienen.

Answer 2

C# CLI ist eine sehr einfache Bibliothek zum Parsen von Kommandozeilenargumenten, die ich geschrieben habe. Sie ist gut dokumentiert und quelloffen.

Answer 3

Powershell Commandlets.

Parsing durch Powershell auf der Grundlage der in den Commandlets angegebenen Attribute, Unterstützung für Validierungen, Parametersätze, Pipelining, Fehlerberichterstattung, Hilfe und vor allem die Rückgabe von .NET-Objekten zur Verwendung in anderen Commandlets.

Ein paar Links, die ich für den Anfang hilfreich fand:

• Schnellstart-Anleitung
• Programmierhandbuch auf MSDN
• Namespace-Referenz auf MSDN

Answer 4

Ich stieß vor kurzem auf die FubuCore Command Line Parsing-Implementierung Ich mag es wirklich, die Gründe sind:

• es ist einfach zu benutzen - obwohl ich keine Dokumentation dafür finden konnte, bietet die FubuCore-Lösung auch ein Projekt mit einer Reihe von Unit-Tests, die mehr über die Funktionalität aussagen, als jede Dokumentation es könnte
• es hat ein schönes objektorientiertes Design, keine Codewiederholungen oder andere Dinge, die ich früher in meinen Kommandozeilen-Parsing-Anwendungen hatte
• Es ist deklarativ: Sie schreiben im Grunde Klassen für die Befehle und Parametersätze und schmücken sie mit Attributen, um verschiedene Optionen festzulegen (z. B. Name, Beschreibung, obligatorisch/optional)
• die Bibliothek druckt sogar ein schönes Nutzungsdiagramm aus, das auf diesen Definitionen basiert

Im Folgenden finden Sie ein einfaches Beispiel für die Verwendung dieser Funktion. Um die Verwendung zu veranschaulichen, habe ich ein einfaches Dienstprogramm mit zwei Befehlen geschrieben: - add (fügt ein Objekt zu einer Liste hinzu - ein Objekt besteht aus einem Namen (string), einem Wert (int) und einem booleschen Flag) - list (listet alle aktuell hinzugefügten Objekte auf)

Als erstes habe ich eine Befehlsklasse für den Befehl "add" geschrieben:

[Usage("add", "Adds an object to the list")]
[CommandDescription("Add object", Name = "add")]
public class AddCommand : FubuCommand<CommandInput>
{
    public override bool Execute(CommandInput input)
    {
        State.Objects.Add(input); // add the new object to an in-memory collection

        return true;
    }
}

Dieser Befehl benötigt eine CommandInput-Instanz als Parameter, also definiere ich diese als nächstes:

public class CommandInput
{
    [RequiredUsage("add"), Description("The name of the object to add")]
    public string ObjectName { get; set; }

    [ValidUsage("add")]
    [Description("The value of the object to add")]
    public int ObjectValue { get; set; }

    [Description("Multiply the value by -1")]
    [ValidUsage("add")]
    [FlagAlias("nv")]
    public bool NegateValueFlag { get; set; }
}

Der nächste Befehl ist "list", der wie folgt implementiert wird:

[Usage("list", "List the objects we have so far")]
[CommandDescription("List objects", Name = "list")]
public class ListCommand : FubuCommand<NullInput>
{
    public override bool Execute(NullInput input)
    {
        State.Objects.ForEach(Console.WriteLine);

        return false;
    }
}

Der Befehl "list" benötigt keine Parameter, daher habe ich eine NullInput-Klasse dafür definiert:

public class NullInput { }

Alles, was jetzt noch übrig ist, ist, dies in der Main()-Methode wie folgt zu verdrahten:

    static void Main(string[] args)
    {
        var factory = new CommandFactory();
        factory.RegisterCommands(typeof(Program).Assembly);

        var executor = new CommandExecutor(factory);

        executor.Execute(args);
    }

Das Programm arbeitet wie erwartet und gibt Hinweise auf die korrekte Verwendung, falls ein Befehl ungültig ist:

  ------------------------
    Available commands:
  ------------------------
     add -> Add object
    list -> List objects
  ------------------------

Und ein Anwendungsbeispiel für den Befehl "add":

Usages for 'add' (Add object)
  add <objectname> [-nv]

  -------------------------------------------------
    Arguments
  -------------------------------------------------
     objectname -> The name of the object to add
    objectvalue -> The value of the object to add
  -------------------------------------------------

  -------------------------------------
    Flags
  -------------------------------------
    [-nv] -> Multiply the value by -1
  -------------------------------------

Answer 5

Mein persönlicher Favorit ist http://www.codeproject.com/KB/recipes/plossum_commandline.aspx von Peter Palotas:

[CommandLineManager(ApplicationName="Hello World",
    Copyright="Copyright (c) Peter Palotas")]
class Options
{
   [CommandLineOption(Description="Displays this help text")]
   public bool Help = false;

   [CommandLineOption(Description = "Specifies the input file", MinOccurs=1)]
   public string Name
   {
      get { return mName; }
      set
      {
         if (String.IsNullOrEmpty(value))
            throw new InvalidOptionValueException(
                "The name must not be empty", false);
         mName = value;
      }
   }

   private string mName;
}