Main() en opdrachtregelargumenten

Artikel
03/14/2024

De Main methode is het toegangspunt van een C#-toepassing. (Bibliotheken en services vereisen Main geen methode als toegangspunt.) Wanneer de toepassing wordt gestart, is de Main methode de eerste methode die wordt aangeroepen.

Er kan slechts één toegangspunt in een C#-programma zijn. Als u meer dan één klasse met een Main methode hebt, moet u het programma compileren met de optie StartupObject compiler om op te geven welke Main methode moet worden gebruikt als toegangspunt. Zie StartupObject (C#-compileropties) voor meer informatie.

class TestClass
{
    static void Main(string[] args)
    {
        // Display the number of command line arguments.
        Console.WriteLine(args.Length);
    }
}

U kunt ook instructies op het hoogste niveau in één bestand gebruiken als het toegangspunt voor uw toepassing. Net zoals de Main methode kunnen instructies op het hoogste niveau ook waarden retourneren en opdrachtregelargumenten openen. Zie Instructies op het hoogste niveau voor meer informatie.

using System.Text;

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

// Display the command line arguments using the args variable.
foreach (var arg in args)
{
    builder.AppendLine($"Argument={arg}");
}

Console.WriteLine(builder.ToString());

// Return a success code.
return 0;

Overzicht

De Main methode is het ingangspunt van een uitvoerbaar programma; het is waar het programma-besturingselement wordt gestart en eindigt.
Main wordt gedeclareerd in een klasse of struct. Main moet zijn static en het hoeft niet te zijn public. (In het eerdere voorbeeld ontvangt het de standaardtoegang van private.) Een omsluiten class kan zijn static.
Mainkan een void, intof TaskTask<int> retourtype hebben.
Indien en alleen als Main een of Task<int>wordt geretourneerdTask, kan de declaratie van Main de wijzigingsfunctie async bevatten. Dit sluit specifiek een async void Main methode uit.
De Main methode kan worden gedeclareerd met of zonder een string[] parameter die opdrachtregelargumenten bevat. Wanneer u Visual Studio gebruikt om Windows-toepassingen te maken, kunt u de parameter handmatig toevoegen of anders de methode gebruiken om de GetCommandLineArgs() opdrachtregelargumenten te verkrijgen. Parameters worden gelezen als nul-geïndexeerde opdrachtregelargumenten. In tegenstelling tot C en C++ wordt de naam van het programma niet behandeld als het eerste opdrachtregelargument in de args matrix, maar het is het eerste element van de GetCommandLineArgs() methode.

In de volgende lijst ziet u geldige Main handtekeningen:

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

In de voorgaande voorbeelden wordt de public wijzigingsfunctie voor accessor gebruikt. Dat is typisch, maar niet vereist.

De toevoeging van async en Task, Task<int> retourtypen vereenvoudigt programmacode wanneer consoletoepassingen moeten starten en await asynchrone bewerkingen in Main.

Main() retourwaarden

U kunt een int van de Main methoden retourneren door de methode op een van de volgende manieren te definiëren:

`Main` methodecode	`Main` Handtekening
Geen gebruik van `args` of `await`	`static int Main()`
Gebruikt `args`, geen gebruik van `await`	`static int Main(string[] args)`
Geen gebruik van `args`, gebruikt `await`	`static async Task<int> Main()`
Gebruikt `args` en `await`	`static async Task<int> Main(string[] args)`

Als de retourwaarde Main niet wordt gebruikt, retourneert void of Task maakt het iets eenvoudigere code mogelijk.

`Main` methodecode	`Main` Handtekening
Geen gebruik van `args` of `await`	`static void Main()`
Gebruikt `args`, geen gebruik van `await`	`static void Main(string[] args)`
Geen gebruik van `args`, gebruikt `await`	`static async Task Main()`
Gebruikt `args` en `await`	`static async Task Main(string[] args)`

Het programma kan echter statusinformatie doorgeven intTask<int> aan andere programma's of scripts die het uitvoerbare bestand aanroepen.

In het volgende voorbeeld ziet u hoe de afsluitcode voor het proces kan worden geopend.

In dit voorbeeld worden .NET Core-opdrachtregelprogramma's gebruikt. Als u niet bekend bent met opdrachtregelprogramma's van .NET Core, kunt u hierover meer informatie vinden in dit aan de slag-artikel.

Maak een nieuwe toepassing door deze uit te voeren dotnet new console. Wijzig de Main methode in Program.cs als volgt:

// Save this program as MainReturnValTest.cs.
class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

Wanneer een programma wordt uitgevoerd in Windows, wordt elke waarde die door de Main functie wordt geretourneerd, opgeslagen in een omgevingsvariabele. Deze omgevingsvariabele kan worden opgehaald uit ERRORLEVEL een batchbestand of $LastExitCode vanuit PowerShell.

U kunt de toepassing bouwen met behulp van de dotnet CLI-opdrachtdotnet build .

Maak vervolgens een PowerShell-script om de toepassing uit te voeren en het resultaat weer te geven. Plak de volgende code in een tekstbestand en sla deze op in test.ps1 de map die het project bevat. Voer het PowerShell-script uit door te typen test.ps1 bij de PowerShell-prompt.

Omdat de code nul retourneert, rapporteert het batchbestand dat is geslaagd. Als u echter MainReturnValTest.cs wijzigt om een niet-nulwaarde te retourneren en vervolgens het programma opnieuw te compileren, rapporteert de volgende uitvoering van het PowerShell-script een fout.

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 hoofd retourwaarden

Wanneer u een async retourwaarde Maindeclareert, genereert de compiler de standaardcode voor het aanroepen van asynchrone methoden in Main. Als u het async trefwoord niet opgeeft, moet u die code zelf schrijven, zoals wordt weergegeven in het volgende voorbeeld. De code in het voorbeeld zorgt ervoor dat uw programma wordt uitgevoerd totdat de asynchrone bewerking is voltooid:

class AsyncMainReturnValTest
{
    public static void Main()
    {
        AsyncConsoleWork().GetAwaiter().GetResult();
    }

    private static async Task<int> AsyncConsoleWork()
    {
        // Main body here
        return 0;
    }
}

Deze standaardcode kan worden vervangen door:

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

    private static async Task<int> AsyncConsoleWork()
    {
        // main body here 
        return 0;
    }
}

Een voordeel van het declareren Main zoals async is dat de compiler altijd de juiste code genereert.

Wanneer het invoerpunt van de toepassing een Task of Task<int>retourneert, genereert de compiler een nieuw toegangspunt dat de invoerpuntmethode aanroept die in de toepassingscode is gedeclareerd. Ervan uitgaande dat dit toegangspunt wordt aangeroepen $GeneratedMain, genereert de compiler de volgende code voor deze toegangspunten:

static Task Main() resulteert in het verzenden van het equivalent van de compiler private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task Main(string[]) resulteert in het verzenden van het equivalent van de compiler private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
static Task<int> Main() resulteert in het verzenden van het equivalent van de compiler private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task<int> Main(string[]) resulteert in het verzenden van het equivalent van de compiler private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Notitie

Als de voorbeelden wijzigingsfunctie voor de Main methode hebben gebruiktasync, zou de compiler dezelfde code genereren.

Opdrachtregelargumenten

U kunt argumenten naar de Main methode verzenden door de methode op een van de volgende manieren te definiëren:

`Main` methodecode	`Main` Handtekening
Geen retourwaarde, geen gebruik van `await`	`static void Main(string[] args)`
Retourwaarde, geen gebruik van `await`	`static int Main(string[] args)`
Geen retourwaarde, gebruikt `await`	`static async Task Main(string[] args)`
Retourwaarde, gebruikt `await`	`static async Task<int> Main(string[] args)`

Als de argumenten niet worden gebruikt, kunt u de methodehandtekening weglaten args voor iets eenvoudigere code:

`Main` methodecode	`Main` Handtekening
Geen retourwaarde, geen gebruik van `await`	`static void Main()`
Retourwaarde, geen gebruik van `await`	`static int Main()`
Geen retourwaarde, gebruikt `await`	`static async Task Main()`
Retourwaarde, gebruikt `await`	`static async Task<int> Main()`

Notitie

U kunt ook de opdrachtregelargumenten gebruiken Environment.CommandLine of Environment.GetCommandLineArgs openen vanaf elk punt in een console- of Windows Forms-toepassing. Als u opdrachtregelargumenten wilt inschakelen in de Main methodehandtekening in een Windows Forms-toepassing, moet u de handtekening Mainvan . De code die door de ontwerpfunctie voor Windows Forms wordt gegenereerd, wordt gemaakt Main zonder invoerparameter.

De parameter van de Main methode is een String matrix die de opdrachtregelargumenten vertegenwoordigt. Meestal bepaalt u of er argumenten bestaan door de Length eigenschap te testen, bijvoorbeeld:

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

Tip

De args matrix kan niet null zijn. Het is dus veilig om toegang te krijgen tot de Length eigenschap zonder null-controle.

U kunt de tekenreeksargumenten ook converteren naar numerieke typen met behulp van de Convert klasse of de Parse methode. Met de volgende instructie wordt bijvoorbeeld het string naar een long getal geconverteerd met behulp van de Parse methode:

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

Het is ook mogelijk om het C#-type longte gebruiken, welke aliassen Int64:

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

U kunt ook de Convert klassemethode ToInt64 gebruiken om hetzelfde te doen:

long num = Convert.ToInt64(s);

Zie voor meer informatie Parse en Convert.

Tip

Het parseren van opdrachtregelargumenten kan complex zijn. Overweeg om de System.CommandLine-bibliotheek (momenteel in bètaversie) te gebruiken om het proces te vereenvoudigen.

In het volgende voorbeeld ziet u hoe u opdrachtregelargumenten gebruikt in een consoletoepassing. De toepassing neemt één argument in runtime, converteert het argument naar een geheel getal en berekent de faculteit van het getal. Als er geen argumenten worden opgegeven, geeft de toepassing een bericht met uitleg over het juiste gebruik van het programma.

Voer de volgende stappen uit om de toepassing te compileren en uit te voeren vanaf een opdrachtprompt:

Plak de volgende code in een teksteditor en sla het bestand op als tekstbestand met de naam 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)
    {
        // Test if input arguments were supplied.
        if (args.Length == 0)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        // Try to convert the input arguments to numbers. This will throw
        // an exception if the argument is not a number.
        // num = int.Parse(args[0]);
        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;
        }

        // Calculate factorial.
        long result = Functions.Factorial(num);

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

        return 0;
    }
}
// If 3 is entered on command line, the
// output reads: The factorial of 3 is 6.

Open in het startscherm of het startmenu een opdrachtpromptvenster van Visual Studio Developer en navigeer naar de map met het bestand dat u hebt gemaakt.
Voer de volgende opdracht in om de toepassing te compileren.

dotnet build

Als uw toepassing geen compilatiefouten bevat, wordt er een uitvoerbaar bestand met de naam Factorial.exe gemaakt.
Voer de volgende opdracht in om de faculteit van 3 te berekenen:

dotnet run -- 3
De opdracht produceert deze uitvoer: The factorial of 3 is 6.

Notitie

Wanneer u een toepassing uitvoert in Visual Studio, kunt u opdrachtregelargumenten opgeven op de pagina Foutopsporing, ProjectOntwerper.

C#-taalspecificatie

Zie de C#-taalspecificatie voor meer informatie. De taalspecificatie is de definitieve bron voor de C#-syntaxis en het gebruik.

Main() en opdrachtregelargumenten

Overzicht

Main() retourwaarden

Asynchrone hoofd retourwaarden

Opdrachtregelargumenten

C#-taalspecificatie

Zie ook

Feedback

Aanvullende resources