Main() és parancssori argumentumok

Cikk
03/14/2024

A Main metódus egy C#-alkalmazás belépési pontja. (A kódtárak és szolgáltatások nem igényelnek metódust Main belépési pontként.) 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, amely rendelkezik Main metódussal, akkor a StartupObject fordítóbeállítással kell lefordítania a programot, hogy megszüntesse a Main belépési pontként használni kívánt metódust. További információ: StartupObject (C# Compiler Options).

class TestClass
{
    static void Main(string[] args)
    {
        // Display the number of command line arguments.
        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.

using System.Text;

StringBuilder builder = new();
builder.AppendLine("The following arguments are passed:");

// Display the command line arguments using the args variable.
foreach (var arg in args)
{
    builder.AppendLine($"Argument={arg}");
}

Console.WriteLine(builder.ToString());

// Return a success code.
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 van deklarálva. Mainkell lenniestatic, és nem kell .public (A korábbi példában a következő alapértelmezett hozzáférést privatekapja: .) A beágyazás class lehet static.
Main lehet egy void, int, Taskvagy Task<int> visszatérési típus.
Ha és csak akkor, ha Main a Task vagy Task<int>, akkor a deklarációban Main szerepelhet a async módosí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 a C++ függvénytől eltérően a program neve nem a tömb első parancssori argumentuma args , hanem a GetCommandLineArgs() metódus első eleme.

Az alábbi lista érvényes Main aláírásokat tartalmaz:

public static void Main() { }
public static int Main() { }
public static void Main(string[] args) { }
public static int Main(string[] args) { }
public static async Task Main() { }
public static async Task<int> Main() { }
public static async Task Main(string[] args) { }
public static async Task<int> Main(string[] args) { }

Az előző példák mindegyike a public kiegészítő módosító használatát használja. Ez tipikus, de nem kötelező.

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

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

A metódusból az Main alábbi módok egyikének megadásával adhat vissza egy int értéket:

`Main` metóduskód	`Main` Aláírás
Nincs használatban vagy `argsawait`	`static int Main()`
Használja `args`, nincs használatban `await`	`static int Main(string[] args)`
Nincs használatban , `args`felhasználás `await`	`static async Task<int> Main()`
Felhasználás `args` és `await`	`static async Task<int> Main(string[] args)`

Ha a visszaadott érték nem használatos, a visszaadott void érték Main némileg egyszerűbb kódot ad vissza vagy Task tesz lehetővé.

`Main` metóduskód	`Main` Aláírás
Nincs használatban vagy `argsawait`	`static void Main()`
Használja `args`, nincs használatban `await`	`static void Main(string[] args)`
Nincs használatban , `args`felhasználás `await`	`static async Task Main()`
Felhasználás `args` és `await`	`static async Task Main(string[] args)`

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:

// Save this program as MainReturnValTest.cs.
class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

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 $LastExitCode a PowerShellből kérhető leERRORLEVEL.

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 void Main()
    {
        AsyncConsoleWork().GetAwaiter().GetResult();
    }

    private static async Task<int> AsyncConsoleWork()
    {
        // Main body here
        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()
    {
        // main body here 
        return 0;
    }
}

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` metóduskód	`Main` Aláírás
Nincs visszatérési érték, nincs használatban `await`	`static void Main(string[] args)`
Visszaadott érték, nincs használatban `await`	`static int Main(string[] args)`
Nincs visszatérési érték, használja `await`	`static async Task Main(string[] args)`
Visszaadott érték, felhasználás `await`	`static async Task<int> Main(string[] args)`

Ha az argumentumok nincsenek használatban, a metódus-aláírásból kihagyhatja args a kissé egyszerűbb kódokat:

`Main` metóduskód	`Main` Aláírás
Nincs visszatérési érték, nincs használatban `await`	`static void Main()`
Visszaadott érték, nincs használatban `await`	`static int Main()`
Nincs visszatérési érték, használja `await`	`static async Task Main()`
Visszaadott érték, felhasználás `await`	`static async Task<int> Main()`

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 engedélyezni szeretné a parancssori argumentumokat egy Windows Forms-alkalmazásban a Main metódus-aláírásban, manuálisan kell módosítania a metódus aláírásá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 osztály vagy a ConvertParse metódus használatával. A következő utasítás például számmá long alakítja a stringParse metódust:

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)
    {
        // Test if input arguments were supplied.
        if (args.Length == 0)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        // Try to convert the input arguments to numbers. This will throw
        // an exception if the argument is not a number.
        // num = int.Parse(args[0]);
        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;
        }

        // Calculate factorial.
        long result = Functions.Factorial(num);

        // Print result.
        if (result == -1)
            Console.WriteLine("Input must be >= 0 and <= 20.");
        else
            Console.WriteLine($"The Factorial of {num} is {result}.");

        return 0;
    }
}
// If 3 is entered on command line, the
// output reads: The factorial of 3 is 6.

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
A parancs a következő kimenetet hozza létre: The factorial of 3 is 6.

Feljegyzés

Ha egy alkalmazást a Visual Studióban futtat, a Project Tervező hibakeresési lapon adhat meg 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

Visszajelzés

További források