Main() a argumenty příkazového řádku

Článek
03/14/2024

Metoda Main je vstupním bodem aplikace jazyka C#. (Knihovny a služby nevyžadují metodu Main jako vstupní bod.) Při spuštění Main aplikace je metoda první metodou, která je vyvolána.

V programu jazyka C# může být pouze jeden vstupní bod. Pokud máte více než jednu třídu, která má metodu Main , musíte zkompilovat program s možností StartupObject kompilátoru určit, kterou Main metodu použít jako vstupní bod. Další informace naleznete v tématu StartupObject (možnosti kompilátoru jazyka C#).

class TestClass
{
    static void Main(string[] args)
    {
        // Display the number of command line arguments.
        Console.WriteLine(args.Length);
    }
}

Příkazy nejvyšší úrovně můžete také použít v jednom souboru jako vstupní bod pro vaši aplikaci. Stejně jako Main metoda můžou příkazy nejvyšší úrovně vracet také hodnoty a argumenty příkazového řádku přístupu. Další informace najdete v tématu Příkazy nejvyšší úrovně.

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;

Přehled

Metoda Main je vstupním bodem spustitelného programu; je místem, kde se spouští a končí ovládací prvek programu.
Main je deklarován uvnitř třídy nebo struktury. Main musí být static a nemusí být public. (V předchozím příkladu obdrží výchozí přístup private.) Ohraničující class může být static.
Main může mít buď typ void, int, Tasknebo Task<int> návratový typ.
Pokud a pouze pokud Main vrátí nebo TaskTask<int>, deklarace Main může obsahovat async modifikátor. Tím se konkrétně vyloučí async void Main metoda.
Metodu Main lze deklarovat pomocí nebo bez parametru, který obsahuje argumenty příkazového string[] řádku. Při vytváření aplikací pro Windows pomocí sady Visual Studio můžete parametr přidat ručně nebo použít metodu GetCommandLineArgs() k získání argumentů příkazového řádku. Parametry se čtou jako argumenty příkazového řádku s nulovým indexem. Na rozdíl od jazyka C a C++ není název programu považován za první argument příkazového řádku v args poli, ale jedná se o první prvek GetCommandLineArgs() metody.

Následující seznam obsahuje platné Main podpisy:

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

Všechny předchozí příklady používají public modifikátor příslušenství. To je typické, ale nevyžaduje se.

Přidání a , návratové async typy zjednodušuje programový kód, když konzolové aplikace potřebují spustit a await asynchronní operace v Main. Task<int>Task

Návratové hodnoty Main()

Metodu intMain můžete vrátit definováním metody jedním z následujících způsobů:

`Main` kód metody	`Main` Podpis
Žádné použití `args` nebo `await`	`static int Main()`
Použití `args`, bez použití `await`	`static int Main(string[] args)`
Žádné použití `args`, použití `await`	`static async Task<int> Main()`
Použití `args` a `await`	`static async Task<int> Main(string[] args)`

Pokud vrácená hodnota z Main není použita, vrácení void nebo Task umožňuje mírně jednodušší kód.

`Main` kód metody	`Main` Podpis
Žádné použití `args` nebo `await`	`static void Main()`
Použití `args`, bez použití `await`	`static void Main(string[] args)`
Žádné použití `args`, použití `await`	`static async Task Main()`
Použití `args` a `await`	`static async Task Main(string[] args)`

int Vrácení nebo Task<int> povolení programu však sdělit informace o stavu jiným programům nebo skriptům, které vyvolávají spustitelný soubor.

Následující příklad ukazuje, jak lze získat přístup k ukončovacímu kódu procesu.

V tomto příkladu se používají nástroje příkazového řádku .NET Core . Pokud neznáte nástroje příkazového řádku .NET Core, můžete se o nich dozvědět v tomto článku začínáme.

Vytvořte novou aplikaci spuštěním dotnet new consolepříkazu . Upravte metodu Main v Program.cs následujícím způsobem:

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

Při spuštění programu ve Windows se jakákoli hodnota vrácená z Main funkce uloží do proměnné prostředí. Tuto proměnnou prostředí je možné načíst pomocí ERRORLEVEL dávkového souboru nebo $LastExitCode z PowerShellu.

Aplikaci můžete sestavit pomocí příkazu dotnet CLIdotnet build .

Dále vytvořte skript PowerShellu pro spuštění aplikace a zobrazte výsledek. Vložte následující kód do textového souboru a uložte ho jako test.ps1 do složky, která obsahuje projekt. Spusťte skript PowerShellu zadáním test.ps1 na příkazovém řádku PowerShellu.

Protože kód vrátí nulu, dávkový soubor ohlásí úspěch. Pokud ale změníte MainReturnValTest.cs vrátit nenulovou hodnotu a pak program znovu zkompilovat, následné spuštění skriptu PowerShellu oznámí selhání.

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

Asynchronní hlavní návratové hodnoty

Když deklarujete návratovou async hodnotu pro Main, kompilátor vygeneruje často používaný kód pro volání asynchronních metod v Main. Pokud nezadáte async klíčové slovo, musíte tento kód napsat sami, jak je znázorněno v následujícím příkladu. Kód v příkladu zajistí, že se program spustí, dokud se nedokončila asynchronní operace:

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

    private static async Task<int> AsyncConsoleWork()
    {
        // Main body here
        return 0;
    }
}

Tento často používaný kód lze nahradit:

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

    private static async Task<int> AsyncConsoleWork()
    {
        // main body here 
        return 0;
    }
}

Výhodou deklarování Main je async , že kompilátor vždy generuje správný kód.

Když vstupní bod aplikace vrátí nebo TaskTask<int>, kompilátor vygeneruje nový vstupní bod, který volá metodu vstupního bodu deklarovanou v kódu aplikace. Za předpokladu, že se tento vstupní bod nazývá $GeneratedMain, kompilátor vygeneruje následující kód pro tyto vstupní body:

static Task Main() výsledkem kompilátoru, který generuje ekvivalent private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task Main(string[]) výsledkem kompilátoru, který generuje ekvivalent private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
static Task<int> Main() výsledkem kompilátoru, který generuje ekvivalent private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task<int> Main(string[]) výsledkem kompilátoru, který generuje ekvivalent private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Poznámka:

Pokud se v metodě použil async modifikátor Main příkladů, kompilátor by vygeneroval stejný kód.

Argumenty příkazového řádku

Argumenty metody Main můžete odeslat definováním metody jedním z následujících způsobů:

`Main` kód metody	`Main` Podpis
Žádná návratová hodnota, bez použití `await`	`static void Main(string[] args)`
Návratová hodnota, bez použití `await`	`static int Main(string[] args)`
Žádná návratová hodnota, použití `await`	`static async Task Main(string[] args)`
Návratová hodnota, použití `await`	`static async Task<int> Main(string[] args)`

Pokud se argumenty nepoužívají, můžete z podpisu metody vynechat args trochu jednodušší kód:

`Main` kód metody	`Main` Podpis
Žádná návratová hodnota, bez použití `await`	`static void Main()`
Návratová hodnota, bez použití `await`	`static int Main()`
Žádná návratová hodnota, použití `await`	`static async Task Main()`
Návratová hodnota, použití `await`	`static async Task<int> Main()`

Poznámka:

Můžete také použít Environment.CommandLine nebo Environment.GetCommandLineArgs přistupovat k argumentům příkazového řádku z libovolného bodu konzoly nebo model Windows Forms aplikace. Chcete-li povolit argumenty příkazového Main řádku v podpisu metody v aplikaci model Windows Forms, je nutné ručně upravit podpis Main. Kód vygenerovaný návrhářem model Windows Forms vytvoří Main bez vstupního parametru.

Parametr Main metody je String pole, které představuje argumenty příkazového řádku. Obvykle určíte, zda argumenty existují testováním Length vlastnosti, například:

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

Tip

Pole args nemůže mít hodnotu null. Je tedy bezpečné přistupovat k Length vlastnosti bez kontroly null.

Řetězcové argumenty můžete také převést na číselné typy pomocí Convert třídy nebo Parse metody. Například následující příkaz převede stringlong číslo na číslo pomocí Parse metody:

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

Je také možné použít typ longjazyka C#, který aliasy Int64:

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

Stejnou věc můžete provést také pomocí Convert metody ToInt64 třídy:

long num = Convert.ToInt64(s);

Další informace najdete v tématech Parse a Convert.

Tip

Analýza argumentů příkazového řádku může být složitá. Pokud chcete proces zjednodušit, zvažte použití knihovny System.CommandLine (aktuálně v beta verzi).

Následující příklad ukazuje, jak používat argumenty příkazového řádku v konzolové aplikaci. Aplikace vezme jeden argument za běhu, převede argument na celé číslo a vypočítá faktoriál čísla. Pokud nejsou zadány žádné argumenty, aplikace vydá zprávu, která vysvětluje správné použití programu.

Pokud chcete aplikaci zkompilovat a spustit z příkazového řádku, postupujte takto:

Do libovolného textového editoru vložte následující kód a uložte ho jako textový soubor s názvem Factorial.cs.

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.

V nabídce Start nebo Start otevřete okno příkazového řádku pro vývojáře sady Visual Studio a přejděte do složky, která obsahuje soubor, který jste vytvořili.
Zadáním následujícího příkazu aplikaci zkompilujte.

dotnet build

Pokud vaše aplikace neobsahuje žádné chyby kompilace, vytvoří se spustitelný soubor s názvem Factorial.exe .
Zadejte následující příkaz pro výpočet faktoriálu 3:

dotnet run -- 3
Příkaz vytvoří tento výstup: The factorial of 3 is 6.

Poznámka:

Při spuštění aplikace v sadě Visual Studio můžete zadat argumenty příkazového řádku na stránce Ladění, Návrhář projektu.

specifikace jazyka C#

Další informace najdete v tématu Specifikace jazyka C#. Specifikace jazyka je úplným a rozhodujícím zdrojem pro syntaxi a použití jazyka C#.

Main() a argumenty příkazového řádku

Přehled

Návratové hodnoty Main()

Asynchronní hlavní návratové hodnoty

Argumenty příkazového řádku

specifikace jazyka C#

Viz také

Váš názor

Další materiály