Main() és parancssori argumentumok

A futtatókörnyezet meghívja a Main metódust egy C#-alkalmazás indításakor. A Main metódus egy C#-alkalmazás belépési pontja.

A C#-programoknak csak egy belépési pontjuk lehet. Ha egynél több osztálya van egy Main metódussal, akkor a program lefordításakor a StartupObject fordítót kell használnia annak megadásához, hogy melyik Main metódus szolgál 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 módszerhez 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 a dotnet <file.cs> parancs használatával, vagy az #!/usr/bin/env dotnet run direktíva első sorban történő alkalmazásával futtathatja (csak Unix rendszerek héjainál).

Áttekintés

A Main metódus egy végrehajtható program belépési pontja. Itt kezdődik és ér véget a program vezérlése.
Osztályban vagy struktúrában kell deklarálnia Main. A burkoló class lehet static.
Main kell lennie static.
Main bármilyen hozzáférés-módosítóval rendelkezhet.
Main visszaadhatja void, int, Task vagy Task<int>.
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 metódust Main parancssori argumentumokat string[] tartalmazó paraméterrel vagy anélkül deklarálhatja. 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éterek nullával indexelt parancssori argumentumok. 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 vagy Task<int> visszatérési típusok alkalmazásával egyszerűsítheti a programkódot, amikor a konzolalkalmazások indítása és az aszinkron műveletek végrehajtása szükséges a konzolalkalmazásokban 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.

Amikor windowsos programot hajt végre, a rendszer a függvényből Main visszaadott értékeket egy környezeti változóban tárolja. Ezt a környezeti változót ERRORLEVEL kötegelt fájl használatával, vagy $LastExitCode PowerShell használatával is lekérheti.

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 egy nemzero értéket adjon vissza, majd újrafordítsa a programot, a PowerShell-szkript későbbi végrehajtása hibát jelez.

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 törzse a metódus törzsén AsyncConsoleWork() belül van.

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ényeként a fordító kibocsátja a private static void $GeneratedMain() => Main().GetAwaiter().GetResult(); megfelelőjét.
static Task Main(string[]) eredményeként a fordító kibocsátja a private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();-el egyenértéket.
static Task<int> Main() eredményezi, hogy a fordító a megfelelő private static int $GeneratedMain() => Main().GetAwaiter().GetResult(); változatot állítja elő.
static Task<int> Main(string[]) hatására a fordító kibocsátja a megfelelő private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult(); értéket.

Feljegyzés

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

Parancssori paraméterek

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 nem használja az argumentumokat, kihagyhatja args a metódusdeklarációból 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 az Length tulajdonság tesztelésével határozza 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 Main metódus elején a program ellenőrzi, hogy nem lettek-e megadva a bemeneti argumentumok azáltal, hogy a args argumentum hosszát összehasonlítja 0-nal; és ha nem találhatóak argumentumok, megjeleníti a súgó üzenetet.
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, a buildelési folyamat létrehoz egy Factorial.dllnevű bináris fájlt.
Adja meg a következő parancsot a 3 faktoriálisának kiszámításához:

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

Feljegyzés

Amikor alkalmazást futtat a Visual Studióban, adja meg a parancssori argumentumokat a Project Designer hibakeresési lapján.

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

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2025-12-17

Megosztás:

Main() és parancssori argumentumok

Áttekintés

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

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

Parancssori paraméterek

C# nyelvspecifikáció

Lásd még

Visszacsatolás

További források