Befehlszeilenargumente in C#-Anwendungen in 10 Minuten oder weniger

Was sind Befehlszeilenargumente?

Zu Beginn erklärt Tim, warum Befehlszeilenargumente wichtig sind. Er vergleicht sie mit der Art und Weise, wie wir Tools wie Docker starten, wo wir Befehle angeben, z. B. welches Image geladen oder welche Aufgabe ausgeführt werden soll. In ähnlicher Weise können Sie in C#-Befehlszeilenanwendungen Parameter übergeben, die das Verhalten des Programms während der Laufzeit festlegen.

Wenn Sie beispielsweise eine Konsolenanwendung zur Verarbeitung von Dateien ausführen, möchten Sie vielleicht den Dateipfad oder -modus über die Befehlszeileneingabe angeben, anstatt den Code zu ändern.

Einrichten des Konsolenprojekts

Tim beginnt in Visual Studio mit einem einfachen .NET 8-Konsolenanwendungsprojekt. Der Standardcode gibt nur eine Meldung wie "Press return to exit" aus und verwendet eine Console.ReadLine()-Anweisung, um vor dem Schließen auf Benutzereingaben zu warten.

Um die Befehlszeileneingabe zu verarbeiten, führt Tim das Array args ein, in dem die Argumente gespeichert werden, die der Anwendung bei der Ausführung übergeben werden. Obwohl moderne C#-Konsolenanwendungen Top-Level-Anweisungen verwenden, haben sie hinter den Kulissen immer noch einen Einstiegspunkt, der wie folgt definiert ist:

static void Main(string[] args)

static void Main(string[] args)

oder manchmal:

static int Main(string[] args)

static int Main(string[] args)

Diese Signaturen stellen die Hauptmethode dar - den Einstiegspunkt, an dem die Ausführung beginnt. Der Parameter args ist ein Array von Strings (string[]), das alle Argumente enthält, die über die Befehlszeile übergeben werden.

Tim demonstriert die Iteration über das args-Array mithilfe einer foreach-Schleife:

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

Hier steht var arg für jedes String-Argument im args-Array, und das Programm zeigt sie in separaten Zeilen in der Konsolenausgabe an.

Tim merkt an, dass die Top-Level-Anweisungen zwar den Boilerplate-Code wie die Klasse Program und die Main-Methode verbergen, aber dennoch alles gleich funktioniert - das Args-Array ist immer verfügbar und bereit, Befehlszeilenargumente zu erfassen.

Ausführen der Konsolenanwendung

Als Nächstes zeigt Tim, wie man diese Funktion testet. Wenn Sie das Programm normal in Visual Studio ausführen, wird nichts anderes angezeigt, da keine Befehlszeileneingabe vorgesehen ist.

Um richtig zu testen, ändert er den Ausführungsprozess manuell: Er öffnet den Datei-Explorer, navigiert zum Ordner bin → Debug → net8.0 des Projekts und startet von diesem Pfad aus ein Terminalfenster.

Von dort aus verwendet er den folgenden Befehl:

ConsoleArgs.exe "hello world" -t timing

ConsoleArgs.exe "hello world" -t timing

Dieser Befehl demonstriert mehrere wichtige Punkte:

• Das in Anführungszeichen gesetzte "hello world" wird als ein String-Argument behandelt, nicht als zwei separate Wörter.

• Das Flag -t und das Wort timing werden als zwei zusätzliche Argumente behandelt.

Bei der Ausführung zeigt die Konsolenausgabe an:

hello world  
-t  
timing

hello world  
-t  
timing

Jedes Zeilenargument steht für ein Element im Args-Array. Tim erklärt, dass dies die korrekte Verwendung von Befehlszeilenargumenten bestätigt - die Konsolenanwendung hat alle während der Ausführung übergebenen Argumente erfolgreich empfangen und angezeigt.

Er erwähnt, dass Entwickler auch dotnet run anstelle des ausführbaren Pfads verwenden können, wenn sie von einem Projektverzeichnis aus arbeiten:

dotnet run -- "hello world" -t timing

dotnet run -- "hello world" -t timing

Der doppelte Bindestrich (--) weist .NET an, alles danach als Befehlszeilenparameter für Ihr Programm zu behandeln, nicht für die .NET CLI selbst.

Behandlung und Analyse von Befehlszeilenargumenten

Da wir nun Argumente lesen können, geht Tim auf den intelligenten Umgang mit Befehlszeilenargumenten ein.

Wenn zum Beispiel -t ein Flag ist, das einen Wert erwartet, muss das Programm wissen, dass es das nächste String-Argument als seinen Wert behandeln soll. Tim zeigt, dass Sie dies manuell analysieren können, indem Sie die Indizes im args-Array überprüfen:

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

Mit diesem Ansatz können Sie benannte Argumente, numerische Typen und sogar Flags für den ausführlichen Modus behandeln. Tim merkt an, dass Entwickler oft eine switch-Anweisung oder sogar externe Dokumentation und Bibliotheken für fortgeschrittenes Argument-Parsing verwenden, aber der System-Namensraum und das args-Array bieten bereits alles, was für grundlegende Fälle benötigt wird.

Erweiterung auf eine Windows Forms-Anwendung

Nach der Demonstration von Konsolenanwendungen geht Tim zu einer Windows Forms-Anwendung (WinForms) über.

Im generierten Code enthält die Datei Program.cs eine statische void-Methode Main(), die jedoch noch keine Parameter akzeptiert. Um Befehlszeilenargumente zu aktivieren, ändert Tim die Main-Methode manuell, um den Parameter args hinzuzufügen:

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

Er erklärt, dass args.FirstOrDefault() den ersten Eingabeparameter aus dem Array args abruft (oder "default" zurückgibt, wenn kein Argument angegeben wird).

Dann aktualisiert Tim in der Klasse Form1 den Konstruktor so, dass er ein String-Argument akzeptiert:

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

Hier ist displayName ein Label, das im Windows Forms Designer definiert wurde und nun das über die Befehlszeile übergebene Argument anzeigt.

Wenn er das Programm ohne Argumente ausführt, zeigt das Etikett "default" an Wenn er es erneut mit ausführt:

WinFormsArgs.exe "Hello World"

WinFormsArgs.exe "Hello World"

das Formularfenster zeigt "Hello World" an

Tim erklärt, dass diese Technik es Windows Forms-Anwendungen ermöglicht, Befehlszeilenargumente genau wie Konsolenanwendungen zu unterstützen - was den Benutzern die Möglichkeit gibt, das Startverhalten dynamisch zu ändern.

Praktische Verwendung von Befehlszeilenargumenten (7:18)

Abschließend geht Tim darauf ein, wie vielseitig Befehlszeilentools mit dieser Funktion werden können. Entwickler können Befehlszeilenargumente verwenden, um:

• Starten Sie Anwendungen in verschiedenen Modi (z. B. Dunkelmodus vs. Lichtmodus).

• Geben Sie Dateipfade oder Konfigurationsoptionen beim Start an.

• Aktivieren Sie den ausführlichen Modus oder Debug-Funktionen mit einfachen Schaltern wie -v oder --debug.

• Erstellen Sie Abkürzungen, die bestimmte Argumente für verschiedene Arbeitsabläufe übergeben.

Indem Sie die Hauptmethode so gestalten, dass sie String-Argumente akzeptiert, können Sie die Flexibilität und Anpassungsfähigkeit Ihrer Anwendung ganz einfach erweitern - ohne zusätzliche Dialoge für Benutzereingaben oder Konfigurationsdateien zu benötigen.

Abschluss (8:15)

Seine an Beispielen orientierte Erklärung zeigt, dass der Umgang mit Kommandozeilenargumenten in C# nicht kompliziert ist - es geht einfach darum zu verstehen, dass jede Anwendung einen Einstiegspunkt (Main) hat, an dem die von der Kommandozeile übergebenen Argumente als String-Array ankommen.

Unabhängig davon, ob Sie mit Konsolenanwendungen oder Windows Forms-Anwendungen arbeiten, ermöglicht dieses Konzept Ihren Programmen, dynamisch auf Befehle, Werte und Parameter zu reagieren, die beim Start angegeben werden.

Abschließendes Fazit

Das Video von Tim Corey bietet einen klaren, praktischen Leitfaden für die korrekte Verwendung von Befehlszeilenargumenten in C#. Wenn Entwickler verstehen, wie der args-Parameter in der Main-Methode funktioniert, können sie auf einfache Weise Argumente für robustere und konfigurierbare Anwendungen erstellen, analysieren und verwenden.

Wenn Sie also das nächste Mal ein C#-Projekt erstellen, denken Sie daran, dass Ihre Befehlszeilenargumente nicht nur eine technische Syntax sind - sie sind die Brücke zwischen Ihrem Programm und seinen Benutzern und verleihen Ihrem Code mehr Leistung, Flexibilität und praktische Verwendbarkeit.