Legfelső szintű utasítások – metódusok nélküli Main programok

Jótanács

Új szoftverfejlesztés? Először az Első lépések oktatóanyagokkal kezdje. Ezek az oktatóanyagok felső szintű utasításokat használnak, így már ismeri az alapokat.

A módszer Main alternatíváját keresi? Lásd a fő metódusbejegyzési pont-ot az explicit metódus megközelítéséhez.

Használjon felső szintű utasításokat az új alkalmazásokhoz. A legfelső szintű utasítások használatával végrehajtható kódot írhat közvetlenül a fájl gyökerénél.

Íme egy Program.cs fájl, amely egy teljes C#-program:

Console.WriteLine("Hello World!");

Ha új konzolalkalmazást hoz létre a használatával dotnet new console, az alapértelmezés szerint legfelső szintű utasításokat használ. Jól működnek bármilyen méretű programokhoz - a kis segédprogramoktól és a Azure Functions a teljes alkalmazásokig. Ha van egy meglévő alkalmazása, amely explicit Main metódust használ, nem kell átalakítania. Mindkét stílus egyenértékű kódra fordít.

A következő szakaszok magyarázzák, hogy mit szabad és mit nem szabad tenni a felső szintű kifejezésekkel.

Belépési pont szabályai

Egy alkalmazásnak csak egy belépési ponttal kell rendelkeznie. Egy projekt csak egy legfelső szintű utasításokkal rendelkező fájllal rendelkezhet, de tetszőleges számú forráskódfájllal rendelkezhet, amelyek nem rendelkeznek legfelső szintű utasításokkal. Explicit módon megírhat egy metódust Main , de nem működhet belépési pontként. Olyan projekteknél, amelyek legfelső szintű utasításokat alkalmaznak, nem tudja kiválasztani a belépési pontot a -main fordítási opcióval, még akkor sem, ha a projekt egy vagy több Main metódussal rendelkezik.

A fordító létrehoz egy metódust, amely egy legfelső szintű utasításokkal rendelkező projekt programbejegyzési pontjaként szolgál. A metódus aláírása attól függ, hogy a legfelső szintű utasítások tartalmazzák-e a await kulcsszót vagy az utasítást return . Az alábbi táblázat azt mutatja be, hogy hogyan néz ki a metódus aláírása a táblázat metódusnevét Main használva a kényelem érdekében.

A legfelső szintű kód tartalmazza Implicit Main aláírás
await és return static async Task<int> Main(string[] args)
await static async Task Main(string[] args)
return static int Main(string[] args)
Nem await vagy return static void Main(string[] args)

A C# 14-től kezdve a programok fájlalapú alkalmazások lehetnek, ahol egyetlen fájl tartalmazza a programot. Fájlalapú alkalmazásokat futtathat a parancs használatával dotnet <file.cs>, vagy közvetlenül a Unix fájlnevével (például ./file.cs). Az utóbbi megköveteli az #!/usr/bin/env dotnet irányelv első sorként való megadását és a végrehajtási engedély (chmod +x <file>) beállítását.

using Irányelvek

A legfelső szintű utasításokat using tartalmazó egyetlen fájl esetében az irányelveknek kell elsőként szerepelnie ebben a fájlban, ahogyan az alábbi példában is látható:

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;

Névterek és típusdefiníciók

A legfelső szintű utasítások implicit módon szerepelnek a globális névtérben. A legfelső szintű utasításokkal rendelkező fájlok névtereket és típusdefiníciókat is tartalmazhatnak, de a legfelső szintű utasítások után kell lenniük. Példa:

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

A legfelső szintű utasítások hivatkozhatnak a változóra, args hogy hozzáférjenek az alkalmazásnak az indításkor átadott parancssori argumentumokhoz. A args változó soha nem null, de Length nulla, ha nem adtak meg parancssori argumentumokat. Példa:

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

await és kilépési kód

Aszinkron metódus meghívására használható await . Ha a felső szintű kód tartalmazza await, a fordító létrehoz egy belépési pontot, ami visszaad egy Task. A futtatási környezet figyeli a Task befejezést, és biztosítja, hogy a folyamat aktív maradjon, amíg minden aszinkron feladat be nem fejeződik. Példa:

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

Ha vissza szeretne adni egy kilépési kódot, amikor az alkalmazás véget ér, használja az utasítást return . A fordító egy belépési pontot hoz létre, amely akkor ad vissza Task<int>, ha a kód tartalmazza mind await és return, vagy int ha csak return található benne. Példa:

string? s = Console.ReadLine();

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

Kapcsolódó tartalom

  • Last updated on