Main() en opdrachtregelargumenten

De Main methode is het toegangspunt van een C#-toepassing. 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. In het volgende voorbeeld wordt het aantal opdrachtregelargumenten weergegeven als eerste actie:

class TestClass
{
    static void Main(string[] args)
    {
        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. In het volgende voorbeeld wordt een foreach lus gebruikt om de opdrachtregelargumenten weer te geven met behulp van de args variabele. Aan het einde van het programma wordt een succescode geretourneerd (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;

Vanaf C# 14 kunnen programma's op bestanden gebaseerde programma's zijn, waarbij één bestand het programma bevat. U voert op bestanden gebaseerde programma's uit met de opdracht dotnet run <file.cs>of gebruikt de #!/usr/local/share/dotnet/dotnet run instructie als eerste regel (alleen unix-shells).

Overzicht

• De Main methode is het ingangspunt van een uitvoerbaar programma. Hier wordt het programma-besturingselement gestart en beëindigd.
• Main moet in een klasse of struct worden gedeclareerd. Het omliggende class kan static zijn.
• Main moet zijn: static.
• Main kan elke toegangsmodifier hebben (met uitzondering filevan).
• Mainkan een void, intof TaskTask<int> retourtype hebben.
• Slechts wanneer Main of Task of Task<int> wordt geretourneerd, kan de declaratie van Main de modificator async bevatten. Deze regel 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 dit is het eerste element van de GetCommandLineArgs() methode.

De volgende lijst bevat de meest voorkomende Main declaraties:

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 de voorgaande voorbeelden wordt geen toegangsmodifier opgegeven, dus zijn ze standaard impliciet private. Het is mogelijk om eventuele expliciete toegangsaanpassingen op te geven.

Main() retourwaarden

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

Als de retourwaarde van Main niet wordt gebruikt, zorgt het retourneren van void of Task voor iets eenvoudiger code.

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:

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

Vergeet niet dit programma op te slaan als MainReturnValTest.cs.

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 de batchfile dat de operatie geslaagd is. Als u echter MainReturnValTest.cs wijzigt om een niet-nulwaarde te retourneren en vervolgens het programma opnieuw te compileren, meldt 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 voor Main declareert, genereert de compiler de standaardcode voor het aanroepen van asynchrone methoden in Main.

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

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

In beide voorbeelden bevindt de hoofdtekst van het programma zich binnen de hoofdtekst van AsyncConsoleWork() methode.

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 erin dat de compiler het equivalent van private static void $GeneratedMain() => Main().GetAwaiter().GetResult(); uitgeeft
• static Task Main(string[]) resulteert erin dat de compiler het equivalent van private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult(); uitgeeft
• static Task<int> Main() resulteert erin dat de compiler het equivalent van private static int $GeneratedMain() => Main().GetAwaiter().GetResult(); uitgeeft
• static Task<int> Main(string[]) resulteert erin dat de compiler het equivalent van private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult(); uitgeeft

Opdrachtregelargumenten

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

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

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;
}

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 long te gebruiken, dat een alias is van 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.

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:

1. 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)
       {
           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;
       }
   }
   

   Aan het begin van de Main methode test het programma of invoerargumenten niet zijn opgegeven met een vergelijking van de lengte van args het argument 0 en geeft de Help weer als er geen argumenten worden gevonden.
   Als argumenten worden opgegeven (args.Length groter dan 0), probeert het programma de invoerargumenten te converteren naar getallen. In dit voorbeeld wordt een uitzondering gegenereerd als het argument geen getal is.
   Nadat factorial is berekend (opgeslagen in result variabele van het type long), wordt het uitgebreide resultaat afgedrukt, afhankelijk van de result variabele.

2. 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.

3. Voer de volgende opdracht in om de toepassing te compileren:

   dotnet build

   Als uw toepassing geen compilatiefouten heeft, wordt er een binair bestand met de naam Factorial.dll gemaakt.

4. Voer het volgende commando in om de faculteit van 3 te berekenen:

   dotnet run -- 3

5. Als 3 wordt ingevoerd op de opdrachtregel als het argument van het programma, leest de uitvoer: The factorial of 3 is 6.

C#-taalspecificatie

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

Zie ook

• System.Environment
• Opdrachtregelargumenten weergeven