Analysieren von Befehlszeilenargumenten in C#

1. Verwenden Sie den CommandLineParser zum Parsen von Argumenten in C#
2. Verwenden Sie die If-Else-Anweisung, um Argumente in C# zu analysieren

In diesem Beitrag wird vorgestellt, wie Befehlszeilenargumente mithilfe der Programmiersprache C# analysiert werden. Wir werden zwei Ansätze und Strategien untersuchen, um dieses Ziel zu erreichen.

Das Standardformat für einen Befehl ist commandName -argumentName argumentValue, wobei commandName der Name des Befehls ist. Nehmen Sie zum Beispiel den bekannten Befehl apt, der in Linux verwendet wird.

apt install exiftool

Verwenden Sie den CommandLineParser zum Parsen von Argumenten in C#

Anstatt Befehle und Argumente manuell zu parsen, könnten Sie eine Bibliothek wie CommandLineParser verwenden, um die Aufgabe für Sie zu erledigen, sodass Sie sich nicht darum kümmern müssen. Ihre primäre Konzentration kann dann darauf gerichtet sein, die Befehlslogik in die Tat umzusetzen.

Wir zeigen Ihnen, wie Sie Code entwickeln, der es CommandLineParser erlaubt, Argumente zu empfangen und Ihre Befehle auf die folgende Weise auszuführen.

static void Main(string[] args) {
  Parser.Default.ParseArguments<UpdateCommand, InstallCommand>(args).WithParsed<ICommand>(
      t => t.Execute());
}

Zuerst müssen Sie das Paket NuGet installieren, was durch Ausführen des folgenden Befehls erledigt werden kann.

Install-Package CommandLineParser

Erstellen Sie eine Basisklasse oder Schnittstelle für Ihre Befehle, falls diese noch nicht vorhanden sind. Andererseits ermöglicht Ihnen das Erstellen einer Schnittstelle, nur einen einzigen .WithParsed<ICommand> in Ihrem Code zu verwenden.

public interface ICommand {
  void Execute();
}

UpdateCommand muss zuerst hinzugefügt werden, dann das Attribut Verb. Dieser Parameter weist CommandLineParser an, ein UpdateCommand-Objekt zu erzeugen, wenn es auf das Wort update trifft.

[Verb("update", HelpText = "updates your system to the newest version")]
public class UpdateCommand : ICommand {
  public void Execute() {
    Console.WriteLine("Updating the system");
  }
}

Geben Sie in diesem Moment den InstallCommand und den message-Parameter des install-Befehls ein. Fügen Sie als direkte Folge die Eigenschaft Message und das Attribut Option hinzu.

Dieses Attribut liefert dem CommandLineParser Anweisungen zur Umwandlung von Argumenten in Eigenschaften.

[Verb("install", HelpText = "installing your software")]
public class InstallCommand : ICommand {
  [Option("message", Required = true, HelpText = "installing the program")]
  public string Message { get; set; }
  public void Execute() {
    Console.WriteLine($"Executing install for the : {Message}");
  }
}

Schließlich übergeben Sie die Argumente an CommandLineParser als Typparameter, um sie zu analysieren.

Verwenden Sie die If-Else-Anweisung, um Argumente in C# zu analysieren

Nachfolgend finden Sie ein Beispiel für das Parsen der Befehlszeilenargumente.

static void Main(string[] args) {
  if (!(args.Length != 0)) {
    Console.WriteLine("arguments not correct");
    return;
  }
}

Der Zweck der Zeile, die static void Main(string[] args) liest, besteht darin, die Argumente von der Befehlszeile abzurufen und sie im args-Array zu speichern. Die Zeile if (!(args.Length != 0)) prüft, ob die Länge der gesamten Argumente 0 ist oder nicht.

Wenn die Länge 0 ist, zeigt dies an, dass dem Programm keine Befehlszeilenargumente übergeben wurden.

Die Zeile mit der Aufschrift Console.WriteLine("arguments not correct"); zeigt auf dem Bildschirm an, dass die Argumente falsch sind, damit der Benutzer beim nächsten Mal die richtige Anzahl von Argumenten eingibt.

var c = args[0];

Die var c = args[0]; line erstellt den Variablennamen c und speichert das erste Argument, das in der Befehlszeile übergeben wird.

if (c == "update") {
  update();
} else if (c == "install") {
  if (args.Length == 2)
    install(args[1]);
} else {
  Console.WriteLine("Invalid Command");
}

Wir werden feststellen, ob die Variable c am Anfang der über die Befehlszeile gesendeten Argumente mit dem Argument update versehen ist oder nicht. Bei positiver Antwort wird die Funktion update() aufgerufen.

Die Bedingung install prüft, ob die Variable c am Anfang das Argument install enthält, und falls ja, bestimmt sie, ob sie zwei Argumente haben soll oder nicht, indem sie die Länge der Variablen args mit 2 vergleicht.

Daher überprüfen wir das in der Parameterliste der Parameter, die ihr über die Befehlszeile gegeben wurden.

Wenn die Länge von args 2 ist, wird die Funktion install() mit args[1] als Parameter aufgerufen.

Der else-Fall wird immer dann ausgeführt, wenn keiner der anderen Fälle zutrifft, woraufhin er auf dem Bildschirm Invalid Command ausgibt.

static void update() {
  Console.WriteLine("updating your system");
}

Die Funktion update() gibt "Updating your system" aus, wenn update als Argument gesendet wird.

static void install(string message) {
  Console.WriteLine($"installing the program {message}");
}

Die Funktion install() gibt "installing the program {message}" aus, wenn install als Argument gesendet wird.

Vollständiger Quellcode:

using System;

class CommandLineParser {
  static void Main(string[] args) {
    if ((args.Length == 0)) {
      Console.WriteLine("arguments not correct");
      return;
    }
    var c = args[0];

    if (c == "update") {
      update();
    } else if (c == "install") {
      if (args.Length == 2)
        install(args[1]);
    } else {
      Console.WriteLine("Invalid Command");
    }
  }
  static void update() {
    Console.WriteLine("updating your system");
  }
  static void install(string message) {
    Console.WriteLine($"installing the program {message}");
  }
}