Instructies op het hoogste niveau - programma's zonder Main methoden

U hoeft geen methode expliciet op te nemen Main in een consoletoepassingsproject. In plaats daarvan kunt u de functie voor instructies op het hoogste niveau gebruiken om de code te minimaliseren die u moet schrijven.

Met instructies op het hoogste niveau kunt u uitvoerbare code rechtstreeks in de hoofdmap van een bestand schrijven, waardoor het niet nodig is om uw code in een klasse of methode te verpakken. Dit betekent dat u programma's kunt maken zonder de ceremonie van een Program klas en een Main methode. In dit geval genereert de compiler een Program klasse met een invoerpuntmethode voor de toepassing. De naam van de gegenereerde methode is niet Main, het is een implementatiedetails waarnaar uw code niet rechtstreeks kan verwijzen.

Hier volgt een Program.cs bestand dat een volledig C#-programma in C# 10 is:

Console.WriteLine("Hello World!");

Met instructies op het hoogste niveau kunt u eenvoudige programma's schrijven voor kleine hulpprogramma's, zoals Azure Functions en GitHub Actions. Ze maken het ook eenvoudiger voor nieuwe C#-programmeurs om aan de slag te gaan met het leren en schrijven van code.

In de volgende secties worden de regels uitgelegd voor wat u wel en niet kunt doen met instructies op het hoogste niveau.

Slechts één bestand op het hoogste niveau

Een toepassing mag slechts één toegangspunt hebben. Een project kan slechts één bestand met instructies op het hoogste niveau bevatten. Het plaatsen van instructies op het hoogste niveau in meer dan één bestand in een project resulteert in de volgende compilerfout:

CS8802 Slechts één compilatie-eenheid kan instructies op het hoogste niveau bevatten.

Een project kan een willekeurig aantal extra broncodebestanden bevatten die geen instructies op het hoogste niveau hebben.

Geen andere toegangspunten

U kunt een Main methode expliciet schrijven, maar deze kan niet fungeren als toegangspunt. De compiler geeft de volgende waarschuwing:

CS7022 Het toegangspunt van het programma is globale code; het ingangspunt 'Main()' wordt genegeerd.

In een project met instructies op het hoogste niveau kunt u de optie -main compiler niet gebruiken om het toegangspunt te selecteren, zelfs niet als het project een of meer Main methoden heeft.

using Richtlijnen

Als u instructies opneemt using , moeten ze eerst in het bestand komen, zoals in dit voorbeeld:

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;

Globale naamruimte

Instructies op het hoogste niveau bevinden zich impliciet in de globale naamruimte.

Naamruimten en typedefinities

Een bestand met instructies op het hoogste niveau kan ook naamruimten en typedefinities bevatten, maar ze moeten achter de instructies op het hoogste niveau komen. Voorbeeld:

MyClass.TestMethod();
MyNamespace.MyClass.MyMethod();

public class MyClass
{
    public static void TestMethod()
    {
        Console.WriteLine("Hello World!");
    }
}

namespace MyNamespace
{
    class MyClass
    {
        public static void MyMethod()
        {
            Console.WriteLine("Hello World from MyNamespace.MyClass.MyMethod!");
        }
    }
}

args

Instructies op het hoogste niveau kunnen verwijzen naar de args variabele voor toegang tot eventuele opdrachtregelargumenten die zijn ingevoerd. De args variabele is nooit null, maar Length de waarde is nul als er geen opdrachtregelargumenten zijn opgegeven. Voorbeeld:

if (args.Length > 0)
{
    foreach (var arg in args)
    {
        Console.WriteLine($"Argument={arg}");
    }
}
else
{
    Console.WriteLine("No arguments");
}

await

U kunt een asynchrone methode aanroepen met behulp van await. Voorbeeld:

Console.Write("Hello ");
await Task.Delay(5000);
Console.WriteLine("World!");

Afsluitcode voor het proces

Als u een int waarde wilt retourneren wanneer de toepassing eindigt, gebruikt u de return instructie zoals in een methode die een intMain retourneert. Voorbeeld:

string? s = Console.ReadLine();

int returnValue = int.Parse(s ?? "-1");
return returnValue;

Impliciete invoerpuntmethode

De compiler genereert een methode om te fungeren als het programmainvoerpunt voor een project met instructies op het hoogste niveau. De handtekening van de methode is afhankelijk van of de instructies op het hoogste niveau het await trefwoord of de return instructie bevatten. In de volgende tabel ziet u hoe de methodehandtekening eruit zou zien, met behulp van de naam Main van de methode in de tabel voor het gemak.

Code op het hoogste niveau bevat	Impliciete Main handtekening
await en return	static async Task<int> Main(string[] args)
await	static async Task Main(string[] args)
return	static int Main(string[] args)
Nee await of return	static void Main(string[] args)

C#-taalspecificatie

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

Functiespecificatie - Instructies op het hoogste niveau