Main() und Befehlszeilenargumente

Die Laufzeit ruft die Main Methode auf, wenn Sie eine C#-Anwendung starten. Die Main-Methode ist der Einstiegspunkt einer C#-Anwendung.

Ein C#-Programm kann nur einen Einstiegspunkt haben. Wenn Sie über mehrere Klassen mit einer Main Methode verfügen, müssen Sie die StartupObject-Compileroption verwenden, wenn Sie das Programm kompilieren, um anzugeben, welche Main Methode als Einstiegspunkt dient. Weitere Informationen finden Sie unter StartupObject (C#-Compileroptionen). Im folgenden Beispiel wird die Anzahl der Befehlszeilenargumente als erste Aktion angezeigt:

class TestClass
{
    static void Main(string[] args)
    {
        Console.WriteLine(args.Length);
    }
}

Sie können anweisungen der obersten Ebene auch in einer Datei als Einstiegspunkt für Ihre Anwendung verwenden. Wie bei der Main Methode können Anweisungen auf oberster Ebene Werte zurückgeben und auf Befehlszeilenargumente zugreifen. Weitere Informationen finden Sie unter Top-Level-Anweisungen. Im folgenden Beispiel wird eine foreach Schleife verwendet, um die Befehlszeilenargumente mithilfe der args Variablen anzuzeigen, und am Ende des Programms wird ein Erfolgscode zurückgegeben (0):

using System.Text;

StringBuilder builder = new();
builder.AppendLine("The following arguments are passed:");

foreach (var arg in args)
{
    builder.AppendLine($"Argument={arg}");
}

Console.WriteLine(builder.ToString());

return 0;

Ab C# 14 können Programme dateibasierte Apps sein, bei denen eine einzelne Datei das Programm enthält. Sie führen dateibasierte Apps mithilfe des Befehls dotnet <file.cs>oder mithilfe der #!/usr/bin/env dotnet run Direktive als erste Zeile aus (nur Unix-Shells).

Übersicht

• Die Main Methode ist der Einstiegspunkt eines ausführbaren Programms. Hier beginnt und endet die Programmsteuerung.
• Sie müssen Main innerhalb einer Klasse oder Struktur deklarieren. Eine einschließende class kann static sein.
• Main muss den Wert static haben.
• Main kann über jeden Zugriffsmodifizierer verfügen.
• Main kann zurückgeben void, , int, Task, oder Task<int>.
• Nur wenn Main ein Task oder Task<int> zurückgibt, kann die Deklaration von Main den async-Modifizierer enthalten. Diese Regel schließt speziell eine async void Main Methode aus.
• Sie können die Main Methode mit oder ohne Parameter string[] deklarieren, die Befehlszeilenargumente enthält. Bei Verwendung von Visual Studio zum Erstellen von Windows-Anwendungen können Sie den Parameter manuell hinzufügen oder die GetCommandLineArgs()-Methode verwenden, um die Befehlszeilenargumente abzurufen. Parameter sind nullindizierte Befehlszeilenargumente. Im Gegensatz zu C und C++ wird der Name des Programms nicht als erstes Befehlszeilenargument im args Array behandelt, aber es ist das erste Element der GetCommandLineArgs() Methode.

Die folgende Liste zeigt die am häufigsten verwendeten Main-Deklarationen:

static void Main() { }
static int Main() { }
static void Main(string[] args) { }
static int Main(string[] args) { }
static async Task Main() { }
static async Task<int> Main() { }
static async Task Main(string[] args) { }
static async Task<int> Main(string[] args) { }

In den vorherigen Beispielen wurde kein Zugriffsmodifizierer angegeben, sodass standardmäßig implizit private verwendet wird. Sie können jeden expliziten Zugriffsmodifizierer angeben.

Main()-Rückgabewerte

Sie können einen int-Wert aus der Main-Methode zurückgeben, indem Sie die Methode auf eine der folgenden Arten definieren:

Wenn der Rückgabewert von Main nicht verwendet wird, kann die Rückgabe von void oder Task einen etwas einfacheren Code ermöglichen.

Die Rückgabe von int oder Task<int> ermöglicht es dem Programm jedoch, Statusinformationen an andere Programme oder Skripts zu übermitteln, die die ausführbare Datei aufrufen.

Im folgenden Beispiel wird gezeigt, wie auf den Exitcode für den Prozess zugegriffen werden kann.

In diesem Beispiel werden Befehlszeilentools von .NET Core verwendet. Wenn Sie mit .NET Core-Befehlszeilentools noch nicht vertraut sind, können Sie in diesem ersten Artikel mehr darüber erfahren.

Erstellen Sie eine neue Anwendung, indem Sie dotnet new console ausführen. Ändern Sie die Main-Methode in program.cs folgendermaßen:

class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

Denken Sie daran, dieses Programm als MainReturnValTest.cszu speichern.

Wenn Sie ein Programm in Windows ausführen, speichert das System jeden wert, der von der Main Funktion in einer Umgebungsvariable zurückgegeben wird. Sie können diese Umgebungsvariable mithilfe ERRORLEVEL einer Batchdatei oder $LastExitCode aus PowerShell abrufen.

Sie können die Anwendung mithilfe des dotnet CLI-Befehlsdotnet build erstellen.

Als Nächstes erstellen Sie ein PowerShell-Skript, das die Anwendung ausführt und die Ergebnisse anzeigt. Fügen Sie folgenden Code in eine Textdatei ein und speichern Sie diese als test.ps1 in dem Ordner, der das Projekt enthält. Führen Sie das PowerShell-Skript aus, indem Sie test.ps1 in die PowerShell-Eingabeaufforderung eingeben.

Da der Code null zurückgibt, meldet die Batchdatei erfolg. Wenn Sie jedoch MainReturnValTest.cs ändern, um einen Wert ungleich Null zurückzugeben und das Programm dann erneut zu kompilieren, meldet die nachfolgende Ausführung des PowerShell-Skripts einen Fehler.

dotnet run
if ($LastExitCode -eq 0) {
    Write-Host "Execution succeeded"
} else
{
    Write-Host "Execution Failed"
}
Write-Host "Return value = " $LastExitCode

Execution succeeded
Return value = 0

Asynchrone Hauptrückgabewerte

Wenn Sie einen async Rückgabewert für Main deklarieren, generiert der Compiler den Codebaustein zum Aufrufen asynchroner Methoden in Main:

class Program
{
    static async Task<int> Main(string[] args)
    {
        return await AsyncConsoleWork();
    }

    private static async Task<int> AsyncConsoleWork()
    {
        return 0;
    }
}

In beiden Beispielen befindet sich der Hauptteil des Programms im Rumpf der Methode AsyncConsoleWork().

Ein Vorteil der Deklarierung von Main als async ist, dass der Compiler immer den richtigen Code generiert.

Wenn der Einstiegspunkt der Anwendung Task oder Task<int> zurückgibt, generiert der Compiler einen neuen Eingangspunkt, der die Eingangspunktmethode abruft, die im Anwendungscode deklariert wurde. Unter der Annahme, dass dieser Einstiegspunkt als $GeneratedMain bezeichnet wird, generiert der Compiler den folgenden Code für diese Einstiegspunkte:

• static Task Main() führt dazu, dass der Compiler das Äquivalent von private static void $GeneratedMain() => Main().GetAwaiter().GetResult(); ausgibt.
• static Task Main(string[]) führt dazu, dass der Compiler das Äquivalent von private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();.
• static Task<int> Main() bewirkt, dass der Compiler das Äquivalent von private static int $GeneratedMain() => Main().GetAwaiter().GetResult(); ausgibt.
• static Task<int> Main(string[]) führt dazu, dass der Compiler das Äquivalent von private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();.

Befehlszeilenargumente

Sie können Argumente an die Main- Methode senden, indem Sie die Methode auf eine der folgenden Arten definieren:

Wenn Sie die Argumente nicht verwenden, können Sie args aus der Methodendeklaration weglassen, um den Code ein wenig zu vereinfachen.

Der Parameter der Main-Methode ist ein String-Array, das die Befehlszeilenargumente darstellt. In der Regel bestimmen Sie, ob Argumente vorhanden sind, indem Sie die Length Eigenschaft testen, z. B.:

if (args.Length == 0)
{
    System.Console.WriteLine("Please enter a numeric argument.");
    return 1;
}

Sie können die Zeichenfolgenargumente auch mit der Convert-Klasse oder der Parse-Methode in numerische Typen konvertieren. Die folgende Anweisung konvertiert z. B. string mithilfe der long-Methode in eine Parse-Zahl:

long num = Int64.Parse(args[0]);

Es ist auch möglich, den C#-Typ long zu verwenden, der Int64 aliasiert:

long num = long.Parse(args[0]);

Sie können für dieselbe Aufgabe auch die Convert-Klassenmethode ToInt64 verwenden:

long num = Convert.ToInt64(s);

Weitere Informationen finden Sie unter Parse und Convert.

Im folgenden Beispiel wird gezeigt, wie Befehlszeilenargumente in einer Konsolenanwendung verwendet werden. Die Anwendung übernimmt zur Laufzeit ein Argument, konvertiert das Argument in eine ganze Zahl und berechnet die Fakultät der Zahl. Wenn keine Argumente übergeben werden, erzeugt die Anwendung eine Meldung, in der die richtige Verwendung des Programms erläutert wird.

Führen Sie die folgenden Schritte aus, um die Anwendung von einer Eingabeaufforderung aus zu kompilieren und auszuführen:

1. Fügen Sie den folgenden Code in einem beliebigen Text-Editor ein, und speichern Sie die Datei als Textdatei mit dem Namen Factorial.cs.

public class Functions
{
    public static long Factorial(int n)
    {
        // Test for invalid input.
        if ((n < 0) || (n > 20))
        {
            return -1;
        }

        // Calculate the factorial iteratively rather than recursively.
        long tempResult = 1;
        for (int i = 1; i <= n; i++)
        {
            tempResult *= i;
        }
        return tempResult;
    }
}

class MainClass
{
    static int Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        int num;
        bool test = int.TryParse(args[0], out num);
        if (!test)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        long result = Functions.Factorial(num);

        if (result == -1)
            Console.WriteLine("Input must be >= 0 and <= 20.");
        else
            Console.WriteLine($"The Factorial of {num} is {result}.");

        return 0;
    }
}

Am Anfang der Main-Methode prüft das Programm, ob keine Eingabeargumente zur Verfügung gestellt wurden, indem es die Länge des args-Arguments mit 0 vergleicht und zeigt die Hilfe an, wenn keine Argumente gefunden werden.
Wenn Argumente angegeben werden (args.Length größer als 0), versucht das Programm, die Eingabeargumente in Zahlen zu konvertieren. In diesem Beispiel wird eine Ausnahme ausgelöst, wenn das Argument keine Zahl ist.
Nachdem die Fakultät (gespeichert in der result-Variablen vom Typ long) berechnet wurde, wird das ausführliche Ergebnis in Abhängigkeit von der result-Variablen gedruckt.

1. Öffnen Sie über den Bildschirm Starten oder das Menü Starten eine Visual Studio Developer-Eingabeaufforderung, und navigieren Sie dann zu dem Ordner, der die Datei enthält, die Sie erstellt haben.

2. Um die Anwendung zu kompilieren, geben Sie den folgenden Befehl ein:

   dotnet build

   Wenn ihre Anwendung keine Kompilierungsfehler aufweist, erstellt der Buildprozess eine Binärdatei mit dem Namen Factorial.dll.

3. Geben Sie den folgenden Befehl ein, um die Fakultät von 3 zu berechnen:

   dotnet run -- 3

4. Wenn Sie 3 in der Befehlszeile als Argument des Programms eingeben, liest die Ausgabe Folgendes: The factorial of 3 is 6.

C#-Sprachspezifikation

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Siehe auch

• System.Environment
• Vorgehensweise: Anzeigen von Befehlszeilenargumenten