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

731

Beim Erstellen von Konsolenanwendungen, die Parameter annehmen, können Sie die übergebenen Argumente verwenden Main(string[] args).

In der Vergangenheit habe ich dieses Array einfach indiziert / geloopt und einige reguläre Ausdrücke verwendet, um die Werte zu extrahieren. Wenn die Befehle jedoch komplizierter werden, kann das Parsen ziemlich hässlich werden.

Ich interessiere mich also für:

  • Von Ihnen verwendete Bibliotheken
  • Von Ihnen verwendete Muster

Angenommen, die Befehle entsprechen immer den allgemeinen Standards, wie sie hier beantwortet werden .

Paul Stovell
quelle
Eine frühere Diskussion, Split-String-enthält-Befehlszeilenparameter-in-String-in-c # , könnte einige Antworten haben.
Gimel
1
Hallo, tut mir leid, es ist ein bisschen unangebracht. Ich verwende jedoch die "Anwendungseinstellungen", um Argumente an die Anwendung zu übergeben. Ich fand es ziemlich einfach zu bedienen und keine Notwendigkeit, Argumente / Datei-Parsing zu schreiben, und keine Notwendigkeit für zusätzliche Bibliothek. msdn.microsoft.com/en-us/library/aa730869(VS.80).aspx
nennen Sie mich Steve
44
@call me Steve: Der Punkt der Befehlszeilenargumente ist, dass sie pro Aufruf variieren können - wie macht man das mit den Anwendungseinstellungen?
Reinierpost

Antworten:

324

Ich würde dringend empfehlen, NDesk.Options ( Dokumentation ) und / oder Mono.Options (gleiche API, unterschiedlicher Namespace) zu verwenden. Ein 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;
}
jonp
quelle
14
NDesk.options ist großartig, scheint aber Konsolen-Apps mit mehr als einem bestimmten Befehl nicht wirklich zu unterstützen. Wenn Sie das wollen, versuchen Sie ManyConsole, die auf NDesk.Options aufbaut: nuget.org/List/Packages/ManyConsole
Frank Schwieterman
5
Wenn ich eine App mit mehreren unterschiedlichen Befehlen habe, "schichte" ich die OptionSets. Nehmen Sie mdoc ( docs.go-mono.com/index.aspx?link=man%3amdoc%281%29 ) mit einem "globalen" OptionSet ( github.com/mono/mono/blob/master/mcs/tools/). mdoc /… ), das an ein OptionSet pro Befehl delegiert (z. B. github.com/mono/mono/blob/master/mcs/tools/mdoc/… )
jonp
3
NDesk keine Arbeit für mich. Konnte ganzzahlige Argumente lesen, aber keine Zeichenfolgen. Die Variablen erhalten weiterhin die Argumente (z. B. 's', 'a' usw.) anstelle der Argumentwerte (z. B. 'Servername', 'Anwendungsname'). Aufgegeben und stattdessen 'Command Line Parser Library' verwendet. Okay so weit.
Jay
2
@AshleyHenderson Zum einen ist es klein und flexibel. Die meisten Lösungen funktionieren nur mit optionalen benannten Argumenten (dh sie können nicht wie git checkout master), oder ihre Argumente sind nicht flexibel (dh sie unterstützen nicht --foo 123= --foo=123= -f 123= -f=123und auch -v -h= -vh).
Wernight
1
@FrankSchwieterman das sollte seine eigene Antwort sein. Und danke für den Tipp, ManyConsole ist ein wahrer Genuss, passt perfekt zu mir.
Quentin-Starin
197

Ich mag die Command Line Parser Library ( http://commandline.codeplex.com/ ) sehr. Es hat 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();
    }
}
Adrian Grigore
quelle
6
Dies ist auch die Bibliothek, in der ich mich niedergelassen habe. Ich schreibe Bewerbungen für ein großes Unternehmen, die über viele Jahre gewartet werden müssen. Diese Bibliothek wurde seit 2005 kontinuierlich aktualisiert, scheint beliebt zu sein, wurde von Personen geschrieben, die in der C # -Community aktiv sind, und ist für den Fall im BSD-Stil lizenziert Unterstützung verschwindet.
Charles Burns
Ich empfehle das auch. Mein einziges Problem war: Die Angabe der zulässigen Argumentationskombination (z. B. wenn das Bewegungsargument auch Quell- und Zielargumente enthalten muss) kann möglicherweise mit Attributen durchgeführt werden. Aber Sie sollten es vielleicht besser mit einer separaten Argument-Validator-Logik machen
Lyndon White,
1
Ich mag die Options-Klasse. Es scheint auch unbenannte Parameter und Flags --recursivezu unterstützen.
Wernight
2
Ich habe es gerade getestet und die Option für meine Anwendung in nur wenigen Minuten implementiert. Die Bibliothek ist sehr einfach zu bedienen.
Trismegistos
3
Ich fand diese Bibliothek für mich sehr restriktiv. Wenn Sie exklusive Sets benötigen, können Sie nicht für jedes Set die erforderlichen Optionen definieren. Sie müssen sie daher manuell überprüfen. Sie können keine Mindestanforderungen für unbenannte Werte definieren, sondern müssen diese auch manuell überprüfen. Help Screen Builder auch überhaupt nicht flexibel. Wenn das Verhalten der Bibliothek nicht sofort Ihren Anforderungen entspricht, können Sie praktisch nichts daran ändern.
Sergey Kostrukov
50

Die WPF TestApi-Bibliothek enthält einen der schönsten Befehlszeilen-Parser für die C # -Entwicklung. Ich empfehle dringend, einen Blick darauf zu werfen , aus 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);
user7116
quelle
19
+1. Das Parsen über die Befehlszeile sollte eigentlich vom Anbieter (z. B. Microsoft) und nicht über ein Tool eines Drittanbieters erfolgen, selbst wenn die Unterstützung des Anbieters rundum erfolgt.
Joel Coehoorn
2
Die akzeptierte Antwort (Mono) ist jedoch die nächstbeste.
Joel Coehoorn
6
@ Joel, welcher Teil ist so wichtig, dass das Parsen der Befehlszeile vom Hersteller stammen muss? Was sind deine Gründe?
Greenoldman
3
@marcias: Ich denke, er meint, es hätte wahrscheinlich Out of the Box sein sollen ... wie viele
andere
Die Bibliothek ist riesig! Enthält so viel mehr als ich brauche ...
Riri
24

Schauen Sie sich http://github.com/mono/mono/tree/master/mcs/class/Mono.Options/ an.

abatishchev
quelle
2
NDesk Optionen hat eine sehr schöne API
user35149
2
Ich werde eine weitere Abstimmung für NDesk hinzufügen, es funktioniert gut, ist nicht aufdringlich und gut dokumentiert.
Terence
1
Mono.GetOptions ist sehr alt, NDesk.Options ist viel schöner (oder Mono.Options, wenn Sie es vorziehen, es ist dieselbe Klasse, hier: anonsvn.mono-project.com/source/trunk/mcs/class/Mono.Options/… )
Matt Enright
7
@ Adam Oren: Meine Antwort ist 1 Jahr und 1 Monat alt! Die Struktur des Monostamms wurde überarbeitet. Dieser Code wird jetzt an anonsvn.mono-project.com/viewvc/branches/mono-2-2/mcs/class/…
abatishchev
6
@Tormod: Es ist Mono.GetOptions, das veraltet ist, nicht Mono.Options. Mono.Options wird weiterhin beibehalten.
Jonp
14

Sieht so aus, als hätte jeder seine eigenen Pet-Kommandozeilen-Parser, ich sollte auch meine hinzufügen :).

http://bizark.codeplex.com/

Diese Bibliothek enthält einen Befehlszeilenparser , der eine Klasse mit den Werten aus der Befehlszeile initialisiert. Es hat eine Menge Funktionen (ich habe es über viele Jahre aufgebaut).

Aus der Dokumentation ...

Das Parsen von Befehlszeilen im BizArk-Framework bietet folgende Hauptfunktionen:

  • 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 einfach mit dem Argument (ex, / 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.
Brian
quelle
2
Ich fand den Befehlszeilenparser von BizArk viel einfacher und fließender als andere. Sehr empfehlenswert!
Boris Modylevsky
9

CLAP (Befehlszeilenargument-Parser) verfügt über eine verwendbare API und ist wunderbar dokumentiert. Sie erstellen eine Methode, indem Sie die Parameter mit Anmerkungen versehen. https://github.com/adrianaisemberg/CLAP

Oberst Panik
quelle
2
Es ist sehr einfach zu bedienen und ihre Website rockt. Ihre Syntax ist jedoch nicht sehr intuitiv: myapp myverb -argname argvalue(muss haben -argname) oder myapp -help(häufig --help).
Wernight
@Wernight können Sie den IsDefault-Parameter für das Verb verwenden, damit er weggelassen werden kann. Ich habe keine Unterstützung für Positionsparameter gefunden, aber ich habe nur Positionsparameter verwendet, als ich die Befehlszeile selbst analysiert habe. Es ist viel klarer, benannte Argumente gefolgt von IMHO-Werten zu verwenden.
Loudenvier
5

Für dieses Problem gibt es zahlreiche Lösungen. Der Vollständigkeit halber und um die Alternative bereitzustellen, wenn jemand dies wünscht, füge ich diese Antwort für zwei nützliche Klassen in meine Google-Codebibliothek ein .

Die erste ist ArgumentList, die nur für das Parsen von Befehlszeilenparametern verantwortlich ist. Es sammelt Name-Wert-Paare, die durch die Schalter '/ x: y' oder '-x = y' definiert sind, und sammelt auch eine Liste von 'unbenannten' Einträgen. Die grundlegende Verwendung wird hier besprochen . Sehen Sie sich die Klasse hier an .

Der zweite Teil davon ist der CommandInterpreter, der aus Ihrer .Net-Klasse eine voll funktionsfähige Befehlszeilenanwendung erstellt. Als Beispiel:

using CSharpTest.Net.Commands;
static class Program
{
    static void Main(string[] args)
    {
        new CommandInterpreter(new Commands()).Run(args);
    }
    //example ‘Commands’ class:
    class Commands
    {
        public int SomeValue { get; set; }
        public void DoSomething(string svalue, int ivalue)
        { ... }

Mit dem obigen Beispielcode können Sie Folgendes ausführen:

Program.exe DoSomething "Zeichenfolgenwert" 5

-- oder --

Program.exe dosomething / ivalue = 5 -svalue: "string value"

Es ist so einfach oder so komplex, wie Sie es brauchen. Sie können den Quellcode überprüfen , die Hilfe anzeigen oder die Binärdatei herunterladen .

csharptest.net
quelle
4

Ich mag das , weil Sie "Regeln definieren" können für die Argumente, benötigt oder nicht, ...

oder wenn Sie ein Unix-Typ sind, könnte Ihnen der GNU Getopt .NET- Port gefallen .

Xn0vv3r
quelle
4

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.

Phill Tew
quelle
Nur zu Ihrer Information, dass Sie einen kleinen Haftungsausschluss machen sollten, dass Sie mit dem Rug.Cmd-Projekt verbunden sind (wie in den FAQ erwähnt): stackoverflow.com/faq#promotion - Keine große Sache, da Sie für ein offenes Projekt werben. Quellprojekt, aber es ist immer noch gut, einen Haftungsausschluss hinzuzufügen;) +1 übrigens ... sieht ziemlich gut aus.
Jason Down
Ein Hoch auf den Hinweis und danke für die +1, ich werde sicherstellen, dass ich meine Zugehörigkeit expliziter darstelle.
Phill Tew
Keine Sorge ... es gibt einige Stickler für diese Art von Dingen (ich bin keiner von ihnen), also gebe ich den Leuten gerne einen Kopf hoch. Auch dies ist normalerweise kein Problem für Open Source-Projekte. Es geht hauptsächlich darum, Menschen davon abzuhalten, Empfehlungen für ihre (bezahlten) Produkte zu spammen.
Jason Down
3

Unter http://www.codeplex.com/commonlibrarynet gibt es einen Parser für Befehlszeilenargumente

Es kann Argumente mit
1. Attributen
2. expliziten Aufrufen
3. einer einzelnen Zeile mit mehreren Argumenten ODER einem String-Array analysieren

Es kann mit folgenden Dingen umgehen:

- config : Qa - startdate : $ { today } - region : 'New York' Settings01

Es ist sehr einfach zu bedienen.


quelle
2

Dies ist ein Handler, den ich basierend auf der Novell- OptionsKlasse geschrieben habe.

Diese richtet sich an Konsolenanwendungen, die eine while (input !="exit")Stilschleife ausführen , beispielsweise eine interaktive Konsole wie eine FTP-Konsole.

Anwendungsbeispiel:

static void Main(string[] args)
{
    // Setup
    CommandHandler handler = new CommandHandler();
    CommandOptions options = new CommandOptions();

    // Add some commands. Use the v syntax for passing arguments
    options.Add("show", handler.Show)
        .Add("connect", v => handler.Connect(v))
        .Add("dir", handler.Dir);

    // Read lines
    System.Console.Write(">");
    string input = System.Console.ReadLine();

    while (input != "quit" && input != "exit")
    {
        if (input == "cls" || input == "clear")
        {
            System.Console.Clear();
        }
        else
        {
            if (!string.IsNullOrEmpty(input))
            {
                if (options.Parse(input))
                {
                    System.Console.WriteLine(handler.OutputMessage);
                }
                else
                {
                    System.Console.WriteLine("I didn't understand that command");
                }

            }

        }

        System.Console.Write(">");
        input = System.Console.ReadLine();
    }
}

Und die Quelle:

/// <summary>
/// A class for parsing commands inside a tool. Based on Novell Options class (http://www.ndesk.org/Options).
/// </summary>
public class CommandOptions
{
    private Dictionary<string, Action<string[]>> _actions;
    private Dictionary<string, Action> _actionsNoParams;

    /// <summary>
    /// Initializes a new instance of the <see cref="CommandOptions"/> class.
    /// </summary>
    public CommandOptions()
    {
        _actions = new Dictionary<string, Action<string[]>>();
        _actionsNoParams = new Dictionary<string, Action>();
    }

    /// <summary>
    /// Adds a command option and an action to perform when the command is found.
    /// </summary>
    /// <param name="name">The name of the command.</param>
    /// <param name="action">An action delegate</param>
    /// <returns>The current CommandOptions instance.</returns>
    public CommandOptions Add(string name, Action action)
    {
        _actionsNoParams.Add(name, action);
        return this;
    }

    /// <summary>
    /// Adds a command option and an action (with parameter) to perform when the command is found.
    /// </summary>
    /// <param name="name">The name of the command.</param>
    /// <param name="action">An action delegate that has one parameter - string[] args.</param>
    /// <returns>The current CommandOptions instance.</returns>
    public CommandOptions Add(string name, Action<string[]> action)
    {
        _actions.Add(name, action);
        return this;
    }

    /// <summary>
    /// Parses the text command and calls any actions associated with the command.
    /// </summary>
    /// <param name="command">The text command, e.g "show databases"</param>
    public bool Parse(string command)
    {
        if (command.IndexOf(" ") == -1)
        {
            // No params
            foreach (string key in _actionsNoParams.Keys)
            {
                if (command == key)
                {
                    _actionsNoParams[key].Invoke();
                    return true;
                }
            }
        }
        else
        {
            // Params
            foreach (string key in _actions.Keys)
            {
                if (command.StartsWith(key) && command.Length > key.Length)
                {

                    string options = command.Substring(key.Length);
                    options = options.Trim();
                    string[] parts = options.Split(' ');
                    _actions[key].Invoke(parts);
                    return true;
                }
            }
        }

        return false;
    }
}
Chris S.
quelle
2

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;
}
Raphael Bossek
quelle
2

Ich bin kürzlich auf die FubuCore-Befehlszeilen-Parsing-Implementierung gestoßen, die mir sehr gut gefällt. Die Gründe dafür sind:

  • Es ist einfach zu bedienen - 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 sprechen als jede Dokumentation
  • Es hat ein schönes objektorientiertes Design, keine Code-Wiederholung oder andere solche Dinge, die ich früher in meinen Befehlszeilen-Parsing-Apps hatte
  • Es ist deklarativ: Sie schreiben grundsätzlich Klassen für die Befehle und Parametersätze und dekorieren sie mit Attributen, um verschiedene Optionen festzulegen (z. B. Name, Beschreibung, obligatorisch / optional).
  • Die Bibliothek druckt sogar ein schönes Nutzungsdiagramm, das auf diesen Definitionen basiert

Unten finden Sie ein einfaches Beispiel für die Verwendung. Um die Verwendung zu veranschaulichen, habe ich ein einfaches Dienstprogramm geschrieben, das zwei Befehle enthält: - add (fügt einer Liste ein Objekt hinzu - ein Objekt besteht aus einem Namen (Zeichenfolge), einem Wert (int) und einem booleschen Flag) - list (Listen) alle aktuell hinzugefügten Objekte)

Zuerst 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 verwendet eine CommandInput-Instanz als Parameter, daher definiere ich Folgendes:

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' akzeptiert keine Parameter, daher habe ich eine NullInput-Klasse dafür definiert:

public class NullInput { }

Jetzt müssen Sie nur noch die Main () -Methode wie folgt verkabeln:

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

        var executor = new CommandExecutor(factory);

        executor.Execute(args);
    }

Das Programm funktioniert wie erwartet und druckt Hinweise zur korrekten Verwendung, falls Befehle ungültig sind:

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

Und eine Beispielverwendung 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
  -------------------------------------
Cristian Lupascu
quelle
2

Powershell Commandlets.

Von Powershell durchgeführte Analyse basierend auf den in den Commandlets angegebenen Attributen, Unterstützung für Validierungen, Parametersätze, Pipelining, Fehlerberichterstattung, Hilfe und am besten die Rückgabe von .NET-Objekten zur Verwendung in anderen Commandlets.

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

hannasm
quelle
2

C # CLI ist eine sehr einfache Parsing-Bibliothek für Befehlszeilenargumente, die ich geschrieben habe. Es ist gut dokumentiert und Open Source.

Bernard
quelle
Gut dokumentiert? Wo ist die Dokumentation?
Suhas
Es gibt eine interne Dokumentation (dh in der Codebasis) sowie eine externe Dokumentation (siehe Readme.mkdDatei im DocumentationOrdner).
Bernard
Ok, habe ich hastig kommentiert. Möglicherweise können Sie Ihr Projekt auf Github verschieben und Ihre Dokumentation wird automatisch auf der Startseite angezeigt.
Suhas
0

Ich würde die Open-Source-Bibliothek CSharpOptParse vorschlagen . Es analysiert die Befehlszeile und hydratisiert ein benutzerdefiniertes .NET-Objekt mit der Befehlszeileneingabe. Ich wende mich immer an diese Bibliothek, wenn ich eine C # -Konsolenanwendung schreibe.

Stuart Lange
quelle
0

Eine sehr einfache, benutzerfreundliche Ad-hoc-Klasse für die Befehlszeilenanalyse, die Standardargumente unterstützt.

class CommandLineArgs
{
    public static CommandLineArgs I
    {
        get
        {
            return m_instance;
        }
    }

    public  string argAsString( string argName )
    {
        if (m_args.ContainsKey(argName)) {
            return m_args[argName];
        }
        else return "";
    }

    public long argAsLong(string argName)
    {
        if (m_args.ContainsKey(argName))
        {
            return Convert.ToInt64(m_args[argName]);
        }
        else return 0;
    }

    public double argAsDouble(string argName)
    {
        if (m_args.ContainsKey(argName))
        {
            return Convert.ToDouble(m_args[argName]);
        }
        else return 0;
    }

    public void parseArgs(string[] args, string defaultArgs )
    {
        m_args = new Dictionary<string, string>();
        parseDefaults(defaultArgs );

        foreach (string arg in args)
        {
            string[] words = arg.Split('=');
            m_args[words[0]] = words[1];
        }
    }

    private void parseDefaults(string defaultArgs )
    {
        if ( defaultArgs == "" ) return;
        string[] args = defaultArgs.Split(';');

        foreach (string arg in args)
        {
            string[] words = arg.Split('=');
            m_args[words[0]] = words[1];
        }
    }

    private Dictionary<string, string> m_args = null;
    static readonly CommandLineArgs m_instance = new CommandLineArgs();
}

class Program
{
    static void Main(string[] args)
    {
        CommandLineArgs.I.parseArgs(args, "myStringArg=defaultVal;someLong=12");
        Console.WriteLine("Arg myStringArg  : '{0}' ", CommandLineArgs.I.argAsString("myStringArg"));
        Console.WriteLine("Arg someLong     : '{0}' ", CommandLineArgs.I.argAsLong("someLong"));
    }
}
Martin Lütken
quelle