Main() és parancssori argumentumok

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 a parancssori argumentumok számát jeleníti meg első műveletként:

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

Egy fájlban felső szintű utasításokat is használhat 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 ciklus használatával foreach jeleníti meg a parancssori argumentumokat a args változó használatával, a program végén pedig egy sikeres kódot ad vissza (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;

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 paranccsal dotnet run <file.cs>, vagy első sorként használja az #!/usr/local/share/dotnet/dotnet run irányelvet (csak Unix-rendszerhéjak esetén).

Áttekintés

A Main metódus egy végrehajtható program belépési pontja, ahol a programvezérlő elindul és véget ér.
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.
Csak akkor, ha Main visszaad egy Task-t vagy Task<int>-t, a Main deklaráció tartalmazhatja a async módosítót. Ez a szabály 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++ nyelven eltérően a program neve nem a args tömb első parancssori argumentuma, 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. 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` , de nem `await`
`static async Task<int> Main()`	Használja `await` , de nem `args`
`static async Task<int> Main(string[] args)`	Használja `args` és `await`

Ha a Main visszaadott érték nincs használva, akkor void vagy Task visszaadása valamivel egyszerűbb kódot tesz lehetővé.

`Main` nyilatkozat	`Main` módszerkód
`static void Main()`	Nincs használatban vagy `argsawait`
`static void Main(string[] args)`	Használja `args` , de nem `await`
`static async Task Main()`	Használja `await` , de nem `args`
`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 sikerességet jelez. 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 meghiúsul.

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

Amikor egy async visszatérési értéket deklarál Main-hez, a fordító létrehozza az aszinkron metódusok meghívásához szükséges sablonkódot a Main-ban.

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 vagy `await`
`static int Main(string[] args)`	Értéket ad vissza, de nem használja `await`
`static async Task Main(string[] args)`	Használ `await` , de nem ad vissza értéket
`static async Task<int> Main(string[] args)`	Érték visszaadása és felhasználása `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 vagy `await`
`static int Main()`	Értéket ad vissza, de nem használja `await`
`static async Task Main()`	Használ `await` , de nem ad vissza értéket
`static async Task<int> Main()`	Értéket ad vissza és használ `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 longis használhatja, amely aliasok Int64:

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 metódus elején a Main program megvizsgálja, hogy a bemeneti argumentumok nem lettek-e megadva, összehasonlítva az argumentum hosszát args0 , és megjeleníti a súgót, ha nem találhatók argumentumok.
Ha argumentumok vannak megadva (args.Length 0-nál nagyobb), a program megpróbálja számmá alakítani a bemeneti argumentumokat. Ez a példa kivételt eredményez, ha az argumentum nem szám.
A faktoriális kiszámítása után (változó típusú resultváltozóban long 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.
Az alkalmazás fordításához írja be a következő parancsot:

dotnet build

Ha az alkalmazás nem rendelkezik fordítási hibával, létrejön egy Factorial.dll nevű bináris 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.

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-07-01

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

Visszajelzés

További források