Dela via

Instruktioner på högsta nivån – program utan Main metoder

Tips/Råd

Är du nybörjare på att utveckla programvara? Börja med självstudierna Komma igång först. De här handledningarna använder toppnivådeklarationer, så du kommer redan att känna till grunderna.

Letar du efter metodalternativet Main ? Se Startpunkten för main-metoden för den explicita Main metodmetoden.

Använd toppnivåinstruktioner för nya appar. Med hjälp av toppnivåinstruktioner kan du skriva körbar kod direkt i roten på en fil.

Här är en Program.cs fil som är ett komplett C#-program:

Console.WriteLine("Hello World!");

När du skapar en ny konsolapp med hjälp dotnet new consoleav använder den toppnivåinstruktioner som standard. De fungerar bra för program av valfri storlek – från små verktyg och Azure Functions till fullständiga program. Om du har ett befintligt program som använder en explicit Main metod behöver du inte konvertera det. Båda formaten kompileras till motsvarande kod.

I följande avsnitt förklaras reglerna för vad du kan och inte kan göra med toppnivåinstruktioner.

Startpunktsregler

En applikation måste ha endast en startpunkt. Ett projekt kan bara ha en fil med toppnivåinstruktioner, men det kan ha valfritt antal källkodsfiler som inte har toppnivåinstruktioner. Du kan uttryckligen skriva en Main metod, men den kan inte fungera som en startpunkt. I ett projekt med toppnivåinstruktioner kan du inte använda kompilatoralternativet -main för att välja startpunkten, även om projektet har en eller flera Main metoder.

Kompilatorn genererar en metod som fungerar som programinmatningspunkt för ett projekt med toppnivåinstruktioner. Metodens signatur beror på om toppnivåinstruktionerna innehåller nyckelordet await eller -instruktionen return . I följande tabell visas hur metodsignaturen ser ut med hjälp av metodnamnet Main i tabellen för enkelhetens skull.

Toppnivåkod innehåller Implicit Main signatur
await och return static async Task<int> Main(string[] args)
await static async Task Main(string[] args)
return static int Main(string[] args)
Nej await eller return static void Main(string[] args)

Från och med C# 14 kan program vara filbaserade appar, där en enda fil innehåller programmet. Du kör filbaserade appar med hjälp av kommandot dotnet <file.cs>eller direkt med filnamnet på Unix (till exempel ./file.cs). Det senare kräver att inkludera direktivet #!/usr/bin/env dotnet som den första raden och ange körningsbehörigheten (chmod +x <file>).

using Direktiv

För den enda fil som innehåller toppnivåinstruktioner using måste direktiven komma först i filen, som i följande exempel:

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;

Namnområden och typdefinitioner

Toppnivåinstruktioner finns implicit i det globala namnområdet. En fil med toppnivåinstruktioner kan också innehålla namnområden och typdefinitioner, men de måste komma efter toppnivåinstruktionerna. Till exempel:

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

Toppnivåinstruktioner kan referera till variabeln args för att komma åt alla kommandoradsargument som skickas till appen när den startas. Variabeln args är aldrig null, men den Length är noll om inga kommandoradsargument angavs. Till exempel:

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

await och avslutningskod

Använd await för att anropa en asynkron metod. När din toppnivåkod innehåller awaitgenererar kompilatorn en startpunkt som returnerar en Task. Körtiden övervakar att Task slutförs, och håller processen vid liv tills allt asynkront arbete har avslutats. Till exempel:

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

Om du vill returnera en slutkod när programmet avslutas använder du -instruktionen return . Kompilatorn genererar en startpunkt som returnerar Task<int> när koden innehåller både await och return, eller int när den bara returninnehåller . Till exempel:

string? s = Console.ReadLine();

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

Relaterat innehåll

  • Last updated on