Main() és parancssori argumentumok

2025-06-17

A Main metódus egy C#-alkalmazás belépési pontja. Az alkalmazás indításakor a Main metódus az első metódus, amelyet meghívunk.

Egy C#-programban csak egy belépési pont lehet. Ha több olyan osztálya van, amelynek Main metódusa van, akkor a StartupObject fordítóbeállítással kell fordítania a programot, hogy meghatározza, melyik Main metódust használja belépési pontként. További információ: StartupObject (C# Compiler Options).
Az alábbi példa azt mutatja, hogy az első végrehajtott sor megjeleníti a parancssori argumentumok számát:

class TestClass
{
    static void Main(string[] args)
    {
        Console.WriteLine(args.Length);
    }
}

A legfelső szintű utasításokat egy fájlban is használhatja az alkalmazás belépési pontjaként. A metódushoz hasonlóan a Main legfelső szintű utasítások is visszaadhatnak értékeket , és elérhetik a parancssori argumentumokat. További információ: Legfelső szintű utasítások.
Az alábbi példa egy foreach ciklust használ a parancssori argumentumok megjelenítéséhez a args változó használatával, a program végén pedig egy sikerkódot (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;

Áttekintés

A Main metódus egy végrehajtható program belépési pontja; itt kezdődik és ér véget a programvezérlő.
Main osztályon vagy szerkezeten belül kell deklarálni. A burkoló class lehet static.
Main kell lennie static.
Main bármilyen hozzáférés-módosítót kaphat (kivéve )
Main lehet egy void, int, Taskvagy Task<int> visszatérési típus.
Kizárólag akkor, ha a Main egy Task vagy Task<int>-t ad vissza, a Main deklarációja tartalmazhatja a async módosítót. Ez kifejezetten kizár egy metódust async void Main .
A Main metódus parancssori argumentumokat tartalmazó paraméterrel vagy anélkül string[] deklarálható. Ha Windows-alkalmazásokat hoz létre a Visual Studióval, manuálisan is hozzáadhatja a paramétert, vagy használhatja a GetCommandLineArgs() metódust a parancssori argumentumok lekéréséhez. A paramétereket a rendszer nulla indexelt parancssori argumentumként olvassa be. A C és C++ nyelvektől eltérően a program neve nem számít első parancssori argumentumnak a args tömbben, hanem a GetCommandLineArgs() metódus első eleme.

Az alábbi listában a leggyakoribb Main deklarációk láthatók:

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) { }

Az előző példák nem adnak meg hozzáférési módosítót, ezért alapértelmezés szerint implicit módon private vannak megadva. Ez jellemző, de bármilyen explicit hozzáférés-módosító megadható.

Tipp.

A async és Task típusok, valamint a visszatérési Task<int> típus hozzáadása leegyszerűsíti a programkódot, amikor a konzolalkalmazásoknak el kell indulniuk, és await aszinkron műveleteket kell végrehajtaniuk Main.

Main() visszatérési értékek

Egy int értéket adhat vissza a Main metódusból azáltal, hogy a metódust az alábbi módok egyikén definiálja:

`Main` nyilatkozat	`Main` módszerkód
`static int Main()`	Nincs használatban vagy `argsawait`
`static int Main(string[] args)`	Használja `args`, nem használja `await`
`static async Task<int> Main()`	Nincs használatban `args`, használatban van `await`
`static async Task<int> Main(string[] args)`	Használja `args` és `await`

Ha a Main visszatérési érték nincs használva, a void vagy Task visszaadása lehetővé teszi a némileg egyszerűbb kódot.

`Main` nyilatkozat	`Main` módszerkód
`static void Main()`	Nincs használatban vagy `argsawait`
`static void Main(string[] args)`	Használja `args`, nem használja `await`
`static async Task Main()`	Nincs használatban `args`, használatban van `await`
`static async Task Main(string[] args)`	Használja `args` és `await`

Ha azonban visszaadja int vagy Task<int> engedélyezi a program számára az állapotinformációk közlését más olyan programokkal vagy szkriptekkel, amelyek meghívják a végrehajtható fájlt.

Az alábbi példa bemutatja, hogyan érhető el a folyamat kilépési kódja.

Ez a példa .NET Core parancssori eszközöket használ. Ha nem ismeri a .NET Core parancssori eszközeit, erről ebben az első lépésekben olvashat.

Hozzon létre egy új alkalmazást a futtatással dotnet new console. Módosítsa a metódust a Main Program.cs az alábbiak szerint:

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

Ne felejtse el menteni ezt a programot MainReturnValTest.cs.

Ha egy programot Windows rendszeren hajt végre, a Main függvényből visszaadott értékek egy környezeti változóban lesznek tárolva. Ez a környezeti változó egy kötegfájlból vagy ERRORLEVEL a PowerShellből kérhető le$LastExitCode.

Az alkalmazást a dotnet CLIdotnet build paranccsal hozhatja létre.

Ezután hozzon létre egy PowerShell-szkriptet az alkalmazás futtatásához és az eredmény megjelenítéséhez. Illessze be a következő kódot egy szövegfájlba, és mentse a test.ps1 projektet tartalmazó mappába. Futtassa a PowerShell-szkriptet a PowerShell-parancssorba való beírással test.ps1 .

Mivel a kód nullát ad vissza, a kötegfájl sikeres lesz. Ha azonban úgy módosítja a MainReturnValTest.cs, hogy nem nulla értéket ad vissza, majd újrafordítja a programot, a PowerShell-szkript későbbi végrehajtása hibát fog jelenteni.

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

Aszinkron fő visszatérési értékek

Ha visszaadott async értéket Maindeklarál, a fordító létrehozza az aszinkron metódusok Mainmeghívására szolgáló sablonkódot. Ha nem adja meg a kulcsszót, ezt a async kódot magának kell megírnia, ahogy az az alábbi példában is látható. A példában szereplő kód biztosítja, hogy a program az aszinkron művelet befejezéséig fusson:

class AsyncMainReturnValTest
{
    public static int Main()
    {
        return AsyncConsoleWork().GetAwaiter().GetResult();
    }

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

Ez a sablonkód a következőre cserélhető:

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

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

Mindkét példában a program fő törzse AsyncConsoleWork() metódus törzsében található.

A deklarálás Mainasync előnye, hogy a fordító mindig a megfelelő kódot hozza létre.

Amikor az alkalmazás belépési pontja visszaad egy Task vagy Task<int>, a fordító létrehoz egy új belépési pontot, amely meghívja az alkalmazáskódban deklarált belépésipont-metódust. Feltételezve, hogy ezt a belépési pontot nevezik $GeneratedMain, a fordító a következő kódot hozza létre ezekhez a belépési pontokhoz:

static Task Main() eredménye a fordítóban, amely a private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task Main(string[]) eredménye a fordítóban, amely a private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
static Task<int> Main() eredménye a fordítóban, amely a private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task<int> Main(string[]) eredménye a fordítóban, amely a private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Feljegyzés

Ha a példák módosítót használnak async a Main metóduson, a fordító ugyanazt a kódot hozza létre.

Parancssori argumentumok

A metódushoz Main az alábbi módok egyikének megadásával küldhet argumentumokat:

`Main` nyilatkozat	`Main` módszerkód
`static void Main(string[] args)`	Nincs visszatérési érték, nincs `await` használat.
`static int Main(string[] args)`	Visszaadott érték, nincs használatban `await`
`static async Task Main(string[] args)`	Nincs visszatérési érték, használja `await`
`static async Task<int> Main(string[] args)`	Visszaadott érték, felhasználás `await`

Ha az argumentumok nincsenek használatban, a metódusdeklarációból kihagyhatja args a kissé egyszerűbb kódokat:

`Main` nyilatkozat	`Main` módszerkód
`static void Main()`	Nincs visszatérési érték, nincs `await` használat.
`static int Main()`	Visszaadott érték, nincs használatban `await`
`static async Task Main()`	Nincs visszatérési érték, használja `await`
`static async Task<int> Main()`	Visszaadott érték, felhasználás `await`

Feljegyzés

A parancssori argumentumokat a konzol vagy a Windows Forms alkalmazás bármely pontjáról használhatja Environment.CommandLine Environment.GetCommandLineArgs vagy elérheti. Ha parancssori argumentumokat szeretne engedélyezni a Main metódusdeklarációban egy Windows Forms-alkalmazásban, manuálisan kell módosítania a metódus deklarációját Main. A Windows Forms designer által létrehozott kód bemeneti paraméter nélkül jön létre Main .

A metódus paramétere Main egy String tömb, amely a parancssori argumentumokat jelöli. Általában a tulajdonság tesztelésével Length állapítja meg, hogy léteznek-e argumentumok, például:

if (args.Length == 0)
{
    System.Console.WriteLine("Please enter a numeric argument.");
    return 1;
}

Tipp.

A args tömb nem lehet null értékű. Így biztonságosan elérheti a tulajdonságot Length null ellenőrzés nélkül.

A sztringargumentumokat numerikus típussá is konvertálhatja az Convert osztály vagy a Parse metódus használatával. Például a következő utasítás a string-t számmá alakítja a long metódus használatával a Parse.

long num = Int64.Parse(args[0]);

A C# típust long is használhatja, amely az Int64 aliasa.

long num = long.Parse(args[0]);

Ugyanezt az Convert osztálymetódust ToInt64 is használhatja:

long num = Convert.ToInt64(s);

További információ: Parse és Convert.

Tipp.

A parancssori argumentumok elemzése összetett lehet. A folyamat egyszerűsítése érdekében fontolja meg a System.CommandLine kódtár (jelenleg bétaverzióban) használatát.

Az alábbi példa bemutatja, hogyan használhatók parancssori argumentumok egy konzolalkalmazásban. Az alkalmazás futtatáskor egy argumentumot használ, az argumentumot egész számmá alakítja, és kiszámítja a szám faktoriálisát. Ha nem ad meg argumentumokat, az alkalmazás egy üzenetet ad ki, amely ismerteti a program helyes használatát.

Az alkalmazás parancssorból való fordításához és futtatásához kövesse az alábbi lépéseket:

Illessze be a következő kódot bármelyik szövegszerkesztőbe, majd mentse a fájlt szövegfájlként Factorial.cs néven.

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

A Main metódus elején a program ellenőrzi, hogy a bemeneti argumentumok nem lettek-e megadva, összehasonlítva args argumentum hosszát 0, és megjeleníti a súgót, ha nem található argumentum.
Ha argumentumok vannak megadva (args.Length nagyobb, mint 0), a program megpróbálja számmá alakítani a bemeneti argumentumokat. Ez kivételt eredményez, ha az argumentum nem szám.
A faktoriális kiszámítása után (resultlongtípusú változóban tárolva) a részletes eredmény a result változótól függően lesz kinyomtatva.

A Kezdőképernyőn vagy a Start menüben nyisson meg egy Visual Studio fejlesztői parancssori ablakot, majd keresse meg a létrehozott fájlt tartalmazó mappát.
Adja meg az alábbi parancsot az alkalmazás fordításához.

dotnet build

Ha az alkalmazás nem rendelkezik fordítási hibával, létrejön egy Factorial.exe nevű végrehajtható fájl.
Adja meg a következő parancsot a 3 faktoriálisának kiszámításához:

dotnet run -- 3
Ha a program argumentumaként 3 értéket ad meg a parancssorban, a kimenet a következő lesz: The factorial of 3 is 6.

Feljegyzés

Ha egy alkalmazást a Visual Studióban futtat, a Project Designer hibakeresési oldalán megadhatja a parancssori argumentumokat.

C# nyelvspecifikáció

További információkért lásd a C# nyelvi specifikációját. A nyelvi specifikáció a C#-szintaxis és -használat végleges forrása.

Megosztás a következőn keresztül:

Main() és parancssori argumentumok

Áttekintés

Main() visszatérési értékek

Aszinkron fő visszatérési értékek

Parancssori argumentumok

C# nyelvspecifikáció

Lásd még

További források