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

MainMetoda je vstupním bodem aplikace v jazyce C#. (Knihovny a služby nevyžadují Main metodu jako vstupní bod.) Po spuštění Main aplikace je metoda první vyvolanou metodou.

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

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

Počínaje jazykem C# 9 můžete vynechat Main metodu a napsat příkazy jazyka C#, jako kdyby byly v Main metodě, jako v následujícím příkladu:


using System.Text;

StringBuilder builder = new();
builder.AppendLine("Hello");
builder.AppendLine("World!");

Console.WriteLine(builder.ToString());

Informace o tom, jak napsat kód aplikace pomocí metody implicitního vstupního bodu, naleznete v tématu příkazy nejvyšší úrovně.

Přehled

  • MainMetoda je vstupním bodem spustitelného programu; je místo, kde se ovládací prvek program spouští a končí.
  • 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 .) Nadřazené třídy nebo struktury není nutné provádět staticky.
  • Main může mít void buď, int nebo, počínaje jazykem C# 7,1, Task nebo Task<int> návratový typ.
  • Pokud a pouze pokud Main vrátí Task nebo Task<int> , deklaraci Main může obsahovat async modifikátor. To konkrétně vylučuje async void Main metodu.
  • MainMetoda může být deklarována s parametrem, který obsahuje argumenty příkazového řádku nebo bez string[] něj. při použití Visual Studio k vytvoření Windows aplikací můžete parametr přidat ručně nebo jinak použít GetCommandLineArgs() metodu k získání argumentů příkazového řádku. Parametry jsou čteny jako argumenty příkazového řádku s nulovým indexem. Na rozdíl od jazyka C a C++ se název programu nepovažuje za první argument příkazového řádku v args poli, ale je prvním prvkem GetCommandLineArgs() metody.

V následujícím seznamu jsou uvedeny platné Main signatury:

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

Předchozí příklady používají public Modifikátor přistupujícího objektu. To je typické, ale není nutné.

Sčítání async a návratové typy zjednodušují kód programu, Task<int>Task když aplikace konzoly potřebují spustit a await asynchronní operace v Main .

Návratové hodnoty Main ()

Můžete vrátit int z Main metody definováním metody jedním z následujících způsobů:

Main kód metody Main označení
Bez použití args nebo await static int Main()
Používá args bez použití await static int Main(string[] args)
Bez použití args , používá await static async Task<int> Main()
Používá args a await static async Task<int> Main(string[] args)

Pokud se návratová hodnota z Main nepoužívá, void vrátí nebo Task povolí lehce jednodušší kód.

Main kód metody Main označení
Bez použití args nebo await static void Main()
Používá args bez použití await static void Main(string[] args)
Bez použití args , používá await static async Task Main()
Používá args a await static async Task Main(string[] args)

Ale vrátí int nebo Task<int> povolí programu, aby komunikoval informace o stavu jiným programům nebo skriptům, které vyvolávají spustitelný soubor.

Následující příklad ukazuje, jak lze použít ukončovací kód procesu.

V tomto příkladu se používají nástroje příkazového řádku .NET Core . Pokud si nejste obeznámeni s nástroji příkazového řádku .NET Core, můžete o nich získat informace v tomto článkuZačínáme.

Vytvořte novou aplikaci spuštěním dotnet new console . MainMetodu v programu program. cs upravte takto:

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

když je program spuštěn v Windows, všechny hodnoty vrácené Main funkcí jsou uloženy v proměnné prostředí. Tato proměnná prostředí se dá načíst pomocí ERRORLEVEL dávkového souboru nebo $LastExitCode z PowerShellu.

Aplikaci můžete vytvořit pomocí příkazu DOTNET CLIdotnet build .

Potom vytvořte PowerShellový skript, který spustí aplikaci a zobrazí výsledek. Vložte následující kód do textového souboru a uložte jej jako test.ps1 ve složce, která obsahuje projekt. Spusťte skript prostředí PowerShell zadáním příkazu test.ps1 do příkazového řádku PowerShellu.

Vzhledem k tomu, že kód vrátí hodnotu nula, dávkový soubor ohlásí úspěch. Pokud ale změníte MainReturnValTest. cs a vrátíte nenulovou hodnotu a pak znovu zkompilujete program, při následném spuštění skriptu PowerShellu se zobrazí zpráva o 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

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

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

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

Tento často používaný kód může být nahrazen:

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

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

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

  • static Task Main() Výsledkem je, že kompilátor emituje ekvivalent private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
  • static Task Main(string[]) Výsledkem je, že kompilátor emituje ekvivalent private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
  • static Task<int> Main() Výsledkem je, že kompilátor emituje ekvivalent private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
  • static Task<int> Main(string[]) Výsledkem je, že kompilátor emituje ekvivalent private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Poznámka

Pokud příklady použili async Modifikátor Main metody, kompilátor vygeneruje stejný kód.

Argumenty příkazového řádku

Argumenty Main metody lze odeslat definováním metody v jednom z následujících způsobů:

Main kód metody Main označení
Žádná návratová hodnota, žádné 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žívá await static async Task Main(string[] args)
Návratová hodnota, používá await static async Task<int> Main(string[] args)

Pokud argumenty nepoužíváte, můžete vynechat args z signatury metody pro mírně jednodušší kód:

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

Poznámka

můžete také použít Environment.CommandLine nebo Environment.GetCommandLineArgs pro přístup k argumentům příkazového řádku z libovolného bodu v konzole nebo model Windows Forms aplikace. chcete-li povolit argumenty příkazového řádku v Main signatuře metody v aplikaci model Windows Forms, je nutné ručně změnit signaturu Main . kód generovaný 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í, otestováním Length vlastnosti, například:

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

Tip

argsPole nemůže mít hodnotu null. Proto je bezpečné přistupovat Length k vlastnosti bez kontroly hodnoty null.

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

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

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

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

Ke stejnému účelu můžete použít Convert také metodu ToInt64 třídy:

long num = Convert.ToInt64(s);

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

Následující příklad ukazuje, jak používat argumenty příkazového řádku v konzolové aplikaci. Aplikace přijímá 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é využití programu.

Chcete-li zkompilovat a spustit aplikaci z příkazového řádku, postupujte podle následujících kroků:

  1. Vložte následující kód do libovolného textového editoru a pak soubor uložte jako textový soubor s názvem faktoriál. 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.
    
  2. z obrazovky start nebo nabídky start otevřete okno Visual Studio Developer Command Prompt a potom přejděte do složky, která obsahuje soubor, který jste vytvořili.

  3. Zadejte následující příkaz pro zkompilování aplikace.

    dotnet build

    Pokud vaše aplikace neobsahuje žádné chyby kompilace, je vytvořen spustitelný soubor s názvem Factorial.exe .

  4. Zadáním následujícího příkazu vypočítáte faktoriál čísla 3:

    dotnet run -- 3

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

Poznámka

při spuštění aplikace v Visual Studio můžete zadat argumenty příkazového řádku na stránce ladění Project Designer.

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#.

Viz také