Delen via

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

Aanbeveling

Nieuw bij het ontwikkelen van software? Begin eerst met de handleiding Aan de slag. In deze handleidingen worden top-level instructies gebruikt, zodat u al bekend bent met de basisbeginselen.

Op zoek naar de alternatieve Main methode? Zie het ingangspunt van de main-methode voor de expliciete Main methodebenadering.

Gebruik instructies op het hoogste niveau voor nieuwe apps. Met behulp van instructies op het hoogste niveau kunt u uitvoerbare code rechtstreeks in de hoofdmap van een bestand schrijven.

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

Console.WriteLine("Hello World!");

Wanneer u een nieuwe console-app maakt met behulp van dotnet new console, worden standaard instructies op het hoogste niveau gebruikt. Ze werken goed voor programma's van elke grootte, van kleine hulpprogramma's en Azure Functions tot volledige toepassingen. Als u een bestaande toepassing hebt die gebruikmaakt van een expliciete Main methode, hoeft u deze niet te converteren. Beide stijlen worden gecompileerd tot gelijkwaardige code.

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

Regels voor toegangspunten

Een toepassing mag slechts één toegangspunt hebben. Een project kan slechts één bestand met instructies op het hoogste niveau hebben, maar kan een willekeurig aantal broncodebestanden bevatten die geen instructies op het hoogste niveau hebben. U kunt expliciet een Main methode schrijven, maar deze kan niet functioneren als toegangspunt. In een project met instructies op het hoogste niveau kunt u de -main compileroptie niet gebruiken om het toegangspunt te selecteren, zelfs niet als het project een of meer Main methoden heeft.

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 eruitziet, met behulp van de methodenaam Main 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)
Geen await of return static void Main(string[] args)

Vanaf C# 14 kunnen programma's op bestanden gebaseerde apps zijn, waarbij één bestand het programma bevat. U voert op bestanden gebaseerde apps uit met behulp van de opdracht dotnet <file.cs>of rechtstreeks met behulp van de bestandsnaam op Unix (bijvoorbeeld ./file.cs). De laatste vereist dat de #!/usr/bin/env dotnet instructie als eerste regel wordt opgenomen en de uitvoermachtiging (chmod +x <file>) wordt ingesteld.

using Richtlijnen

Voor het enige bestand dat topniveaudirectieven bevat, moeten de directieven eerst in dat bestand komen, zoals in het volgende voorbeeld.

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;

Naamruimten en typedefinities

Instructies op het hoogste niveau bevinden zich impliciet in de globale naamruimte. 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 opdrachtregelargumenten die aan de app worden doorgegeven wanneer deze wordt gestart. De args variabele is nooit null, maar Length de variabele 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 en afsluitcode

Gebruik await dit om een asynchrone methode aan te roepen. Wanneer uw toplevelcode await bevat, genereert de compiler een instappunt die een Task retourneert. De runtime bewaakt dat Task voor voltooiing, waardoor het proces actief blijft totdat alle asynchrone werkzaamheden zijn voltooid. Voorbeeld:

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

Als u een afsluitcode wilt retourneren wanneer de toepassing eindigt, gebruikt u de return instructie. De compiler genereert een toegangspunt dat Task<int> retourneert wanneer uw code zowel await als return bevat, of int retourneert wanneer deze alleen return bevat. Voorbeeld:

string? s = Console.ReadLine();

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

Verwante inhoud

  • Last updated on