Parser für Kommandozeilenparameter (CommandLineArguments)

Beschreibung:

Diese Komponente ist ein Parser für Kommandozeilenparameter (CommandLineArguments).

Die unterstützten Parameter-Start-Formate sind: /arg (slash), -arg (dash), --arg (double dash).
Die unterstützten Zuweisungs-Operatoren sind: /x=0 (equals), /x:0 (colon).
Die unterstützten String-Formate sind: /x="string" (double quotes), /x='string' (single quotes).
Die unterstützten Zahlen-Formate sind (bis jetzt) nur Integer-Literale.
Die unterstützen Parameter-Typen (ArgumentType) sind (bis jetzt) folgende:*/arg --> Flag (true) */!arg --> Flag (false) */arg=123 --> Number (123) */arg='value' --> String (value) */arg=123;234;345 --> NumberSet (123,234,345) */arg='asd';"qwertz";'öäü' --> StringSet (asd,qwertz,öäü) */arg='asd';123;'öäü' --> MixedSet (asd,123,öäü)

Beispiele:
"C:\path\to\app.exe" /debug /option1="C:\temp\test.ext" /option2="String with \" escaped quotes" /option3=123

"C:\path\to\app.exe" /search /dir="C:\pics" /extensions="bmp";"png";"jpg";"jpeg"

Verwendung:

using System;
using BrainFx.CommandLine

namespace BrainFx.Tester
{
    public static class Program
    {
        public static void Main()
        {
            // Initialisierung der Kommandozeilenparameter
            var args = new CommandLineArguments();

            // Wenn der Parameter "debug" existiert, ein Flag ist und wahr ist, dann...
            if (args["debug"] != null &&
                args["debug"].Type == ArgumentType.Flag &&
                (Boolean) args["debug"].Value)
            {
                Console.WriteLine("Debug mode enabled!");
            }

            // Wenn der Parameter "test" existiert und ein String ist, dann...
            if (args["test"] != null &&
                args["test"].Type == ArgumentType.String)
            {
                var test = (String) args["test"].Value;

                Console.WriteLine("Test: '{0}'", test);
            }
        }
    }
}

Ich würde mich über eure Rückmeldung freuen. Wenn jemandem noch weitere Schreibweisen einfallen, bitte einfach melden. Ich versuche sie dann einzubauen.

Gruß, Christian.

ChangeLog:*Linux Support hinzugefügt *Möglichkeit, Dateinamen direkt als Parameter zu übergeben (MyApp.exe foo.txt /action=delete) *Fehler nicht mehr als Exception, sondern als Eigenschaft der Klasse CommandLineArguments (.Success und .Message)

Alter Download-Counter : 122

Schlagwörter: command line arguments parser kommando zeile parameter

Hallo Schamese,

ich habe mal Deine Core-Klasse kompiliert und mt einem Konsolenprogrämmchen getestet
Ich erhalte leider immer beim Erstellen des CommandLineArguments-Objekts die Exception:

System.ArgumentException: An element with the same key already exists in the dictionary.
  at System.Collections.Generic.Dictionary`2[System.String,BrainGameFx.CommandLine.Argument].Add (System.String key, BrainGameFx.CommandLine.Argument value) [0x00000]
  at BrainGameFx.CommandLine.Lexer.DoLexing () [0x00000]
  at BrainGameFx.CommandLine.CommandLineArguments..ctor () [0x00000]
  at TestConsole.MainClass.Main () [0x00000]

Hier mein (minimierter) Testcode:

  public static void Main()
    {
      try
      {
        BrainGameFx.CommandLine.CommandLineArguments a = 
          new BrainGameFx.CommandLine.CommandLineArguments(); // <-- hier die Exception
      }
      catch(Exception e){
        Console.Write(e);
      }
      Console.Read();
  }

Vielleicht sollte ich dazusagen, dass das jetzt unter Linux/Mono ist... ich prüfe das mal morgen unter Windows nach und sage Bescheid wie's da ist.
Der Feher tritt bei mir auch dann auf, wenn ich gar keine Argumente übergebe.

Ansonsten fände ich es praktisch, wenn Du in der Klasse CommandLineArguments noch eine Contains(string name)-Methode anbieten würdest, damit man prüfen kann ob ein bestimmtes Argument überhaupt übergeben wurde (Dictionary.ContainsKey fällt ja flach weil Dein Dictionary private ist).
Das Argument auf null zu pfüfen wird nicht funktionieren, da das Dictionary eine Exception werfen sollte wenn mit einem ungültigen Key zugegriffen wird.

Gruß, MarsStein

Hi, MarsStein.

Das mit dem Dictionary passiert vermutlich, wenn du einen Parameter mehrmals übergibst. Kannst du mal die Kommandozeile posten, die du benutzt hast?

Ansonsten fände ich es praktisch, wenn Du in der Klasse CommandLineArguments noch eine Contains(string name)-Methode anbieten würdest, damit man prüfen kann ob ein bestimmtes Argument überhaupt übergeben wurde (Dictionary.ContainsKey fällt ja flach weil Dein Dictionary private ist).
Das Argument auf null zu pfüfen wird nicht funktionieren, da das Dictionary eine Exception werfen sollte wenn mit einem ungültigen Key zugegriffen wird.

Ich habe es so implementiert, dass man null zurückbekommt, wenn der Indexer einen Wert nicht findet (síehe auch in meinem Beispielcode oben):

public Argument this[String name]
{
    get
    {
        name = name.ToLower().Trim();

        if (m_Arguments.ContainsKey(name))
        {
            return m_Arguments[name];
        }

        return null;
    }
}

Gruß, Christian.

Hallo Schamese,

dann stimmt die Version im Zip-Archiv nicht. Möglicherweise erklärt das auch die Exception.
Denn dort ist es (noch) so implentiert:

        public Argument this[String name]
        {
            get
            {
                return m_Arguments[name];
            }
        }

Gruß, MarsStein

Edit: Ich habe den Fehler mit jeder Kommandozeile, selbst mit einer leeren 🤔

Hi, MarsStein.

Ich hab jetzt nochmal den aktuellsten Stand hochgeladen. Kannst du es bitte noch einmal probieren? Ich meine mich erinnern zu können, dass ich das Problem mit dem Dictionary schon beseitigt hatte (aber wahrscheinlich vergessen neu hochzuladen...)

Gruß, Christian.

Hallo Schamese,

jetzt ist die Implementierung bezüglich der Nullprüfung drin 🙂

Das Problem mit dem Dictionary besteht weiterhin, allerdings tatsächlich nur unter Linux/Mono. Das Problem dürfte der Pfad zur Anwendung sein, der ganz vorne in Environment.CommandLine steht, und unter Linux z.B. so aussieht:

/home/marsstein/code/csharp**/consoletest/consoletest**/bin/Debug/consoletest.exe

ich vermute der wird mitgeparst und aufgrund der "/" als Argument erkannt. Das doppelte Argument könnte dann von so etwas wie der fett markierten Stelle kommen.

Gruß, MarsStein

Hi, MarsStein.

Mit dem Pfad unter Linux/Mono hast du Recht. Ich werds morgen mal unter Mono zum Laufen bringen und Montag oder Dienstag neu hochladen.

Heute hab ich keine Zeit mehr.

Hab mir auch gerade überlegt, dass, wenn Argumente doppelt angegeben werden, die angehängten Werte in einem Set mit dem Namen des Arguments gespeichert werden sollten. Dann kann man Argumente auch doppelt vergeben.

C:\my\app.exe /test=12 /test="string" würde dann also ein MixedSet mit dem Namen "test" und den Werten 12 und "string" ergeben.

Gruß, Christian.

Hallo!

@Schamese:

Dann kann man Argumente auch doppelt vergeben.

Das halte ich für ungünstig. Man sollte es entweder direkt als MixedSet angeben, oder der Parser sollte einen Fehler auswerfen.
Es erscheint einfach unlogisch, wenn man test etwas zuweist und (ggf. erst nach anderen Parametern) dann wieder was anderes.

EDIT: Habe mittlerweile selbst feststellen müssen, dass meine Aussage falsch ist. Z.B. nimmt 7-Zip über mehrere -x-Switche eine Liste zu ignorierender Dateien und Verzeichnisse auf.

Hallo tom-essen,

nein, es gibt durchaus Fällen, in denen man mehrere gleiche Argumente mit unterschiedlichen Werten verwendet, z.B.

csc /D:DEBUG /D:CUSTOMER1 /r:a.dll /r:b.dll x.c

Das sollte ein Parser für Kommandozeilenparameter also durchaus unterstützen, mindestens optional.

herbivore

So.

Das Linux-Problem wäre jetzt behoben. Ich habe den Download neu rein gestellt.

Gruß, Christian.

Hi,

die Komponente ist super. Ich bekomme nur leider eine Exception, wenn ich double quotes verwende.

Also:

app.exe -directory="test"

geht nicht. Während

app.exe -directory='test'

funktioniert.

Gruß

Christoph

Hi!

Freut mich, dass die Komponente gefällt!

Habe das Problem beseitigt.

Einfach den Konstruktor von CommandLineArguments wie folgt anpassen:

public CommandLineArguments()
{
    var parser = new Parser(Environment.CommandLine);

    parser.Parse();

    var lexer = new Lexer(parser.Tokens);

    lexer.DoLexing();

    ExecutablePath = Process.GetCurrentProcess().MainModule.FileName;
    m_Arguments = lexer.Arguments;
}

Im ersten Post ist jetzt auch wieder die aktuellste Version.

Gruß, Christian.

Hallo Christian,

leider funktioniert es für mich jetzt gar nicht mehr:

Ich führe folgenden Befehl aus:

Console.exe -directory='test'

und erhalte dann diese Exception:

Unbehandelte Ausnahme: System.InvalidOperationException: 'ArgumentStart' expecte
d!
   bei BrainFx.Core.CommandLine.Lexer.DoLexing() in D:\git\utilities\src\BrainFx
.Core.CommandLine\CommandLine\Lexer.cs:Zeile 63.
   bei BrainFx.Core.CommandLine.CommandLineArguments..ctor() 

Gruß

Christoph

Kann ich leider nicht reproduzieren.

Wie sieht deine Kommandozeile genau aus?

MyApp.Exe -directory='test' oder MyApp.Exe Console.Exe -directory='test'?

Zweiteres wir nämlich den o.g. Fehler produzieren, da Console.Exe kein gültiger Parameter ist.

Gruß, Christian.

Hallo TheBrainiac,

da Console.Exe kein gültiger Parameter ist.

einfache Strings ohne besonderes Format sollten schon möglich sein, schon alleine, damit man die Kommandozeilen von Programmen verarbeiten kann, die Dateinamen als Parameter bekommen, z.B. mycopy Console.Exe Console.Exe.bak.

Außerdem wäre zu überlegen, ob es nicht einen besseren Weg gibt, Syntaxfehler in der zu parsenden Kommandozeile zu melden, als über Exceptions. Immerhin wird die Kommandozeile oft eine Benutzereingabe sein und für solche gilt im Allgemeinen: besser TryParse statt Parse verwenden.

herbivore

So.

Ich habe die Klasse erneut angepasst.

Außerdem wäre zu überlegen, ob es nicht einen besseren Weg gibt, Syntaxfehler in der zu parsenden Kommandozeile zu melden, als über Exceptions. Immerhin wird die Kommandozeile oft eine Benutzereingabe sein und für solche gilt im Allgemeinen: besser TryParse statt Parse verwenden.

Da hast du allerdings recht. Ich habe es jetzt so angepasst, dass der Lexer Fehler über die Properties Success und Message meldet, nicht mehr über Exceptions.

einfache Strings ohne besonderes Format sollten schon möglich sein, schon alleine, damit man die Kommandozeilen von Programmen verarbeiten kann, die Dateinamen als Parameter bekommen, z.B. mycopy Console.Exe Console.Exe.bak.

Auch das ist jetzt möglich, allerdings muss man sich dann um die Verarbeitung der Parameter selbst kümmern, da diese vom ArgumentTyp Unknown sind. Außerdem werden diese einfach durchnummeriert (arg1, arg2, arg3...).

Gruß, Christian.

Hallo Christian,

hast du auch eine lauffähige Version für das Framework 2.0?

Ich versuche es unter 2.0 zum laufen zu bringen. Irgendwie klappt es nicht...

EDIT: Ich hab es nun hingekriegt nur wenn ich das Argument "/?" übergebe, wird dies nicht erkannt. So wie es aussieht erwartest du nach dem Identifier einen Buchstaben und "?" gehört nicht dazu.

Danke
Steffen

Hallo!

@steffen_dec:
Was genau geht den "irgendwie" nicht?

Hallo,

ich habe nun die Parser.Pase()-Methode erweitert damit "/?" richtig erkannt wird.

        public void Parse() {
            bool stringOpen = false;
            bool numberOpen = false;
            bool identifierOpen = false;
            Char stringChar = '\0';
            StringBuilder value = default(StringBuilder);

            while (Read()) {
                if ("?".Contains(Current.ToString()) && !stringOpen && !identifierOpen)
                {
                    identifierOpen = true;
                    value = new StringBuilder();

                    value.Append(Current);

                    if (!(Char.IsLetter(Next) || Char.IsNumber(Next) || Next == '_'))
                    {
                        m_Tokens.Add(new Token(TokenType.Identifier, value.ToString()));

                        identifierOpen = false;
                        value = null;
                    }
                }
                else if (Char.IsLetter(Current) && !stringOpen && !identifierOpen) {
                    identifierOpen = true;
                    value = new StringBuilder();

                    value.Append(Current);
                } else if (identifierOpen && (Char.IsLetter(Current) || Char.IsNumber(Current) || Current == '_')) {
                    value.Append(Current);

                    if (!(Char.IsLetter(Next) || Char.IsNumber(Next) || Next == '_')) {
                        m_Tokens.Add(new Token(TokenType.Identifier, value.ToString()));

                        identifierOpen = false;
                        value = null;
                    }
                } else if (Char.IsNumber(Current) && !stringOpen && !numberOpen && !identifierOpen) {
                    numberOpen = true;
                    value = new StringBuilder();

                    value.Append(Current);
                } else if (numberOpen && Char.IsNumber(Current)) {
                    value.Append(Current);

                    if (!"0123456789".Contains(Next.ToString())) {
                        m_Tokens.Add(new Token(TokenType.Number, value.ToString()));

                        numberOpen = false;
                        value = null;
                    }
                } else if ("\"'".Contains(Current.ToString()) && !stringOpen) {
                    stringOpen = true;
                    stringChar = Current;
                    value = new StringBuilder();
                } else if (stringOpen && Current == stringChar) {
                    m_Tokens.Add(new Token(TokenType.String, value.ToString()));

                    stringOpen = false;
                    stringChar = '\0';
                    value = null;
                } else if (stringOpen && Current == '\\' && (Next == '\\' || Next == '"' || Next == '\'')) {
                    value.Append(Next);
                    Read();
                } else if (stringOpen) {
                    value.Append(Current);
                } else if ("/-".Contains(Current.ToString())) {
                    string start = Current.ToString();

                    if (Current == '-' && Next == '-') {
                        Read();
                        start += Current;
                    }

                    m_Tokens.Add(new Token(TokenType.ArgumentStart, start));
                } else if (":=".Contains(Current.ToString())) {
                    m_Tokens.Add(new Token(TokenType.Assign, Current.ToString()));
                } else if (Current == '!') {
                    m_Tokens.Add(new Token(TokenType.Negation, Current.ToString()));
                } else if (Current == ';') {
                    m_Tokens.Add(new Token(TokenType.Seperate, Current.ToString()));
                } else if (!Char.IsWhiteSpace(Current)) {
                    m_Tokens.Add(new Token(TokenType.Invalid, Current.ToString()));
                }
            }
        }

nun bin ich zufrieden, danke für die tolle Komponente!

Hallo zusammen!

Ich danke auch für diese tolle Komponente! Auch wenn der Thread schon älter ist, würde ich gern die Frage hierzu stellen, wie ich denn auf NumberSets und Stringsets dann zugreifen kann.

Also wenn mein Aufruf

Test.exe /Nummern=1;2;3 /Woerter="Test1";"Test2";"Test3"

lautet, so habe ich unter args die 2 Argumententypen NumberSet und StringSet. Aber da mein Wissen mit den List-Objekten noch begrenzt ist und ich an solchen Beispielen gern lerne, hoffe ich, eine Antwort darauf zu bekommen, wie ich denn nun herausfinde, wieviele Einträge das NumberSet/Stringset nun hat und wie die Adressierung ist!

Das Beispiel im ersten Posting zeigt leider nichts davon.

Mit besten Grüßen
Nils