Main() i argumenty wiersza polecenia

Metoda Main jest punktem wejścia aplikacji języka C#. Po uruchomieniu aplikacji metoda Main jest pierwszą wywoływaną.

W programie języka C# może istnieć tylko jeden punkt wejścia. Jeśli masz więcej niż jedną klasę, która ma metodę Main , musisz skompilować program z opcją kompilatora StartupObject , aby określić Main metodę używaną jako punkt wejścia. Aby uzyskać więcej informacji, zobacz StartupObject (Opcje kompilatora C#). Poniższy przykład przedstawia liczbę argumentów wiersza polecenia jako pierwszą akcję:

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

Instrukcje najwyższego poziomu można również użyć w jednym pliku jako punktu wejścia dla aplikacji. Podobnie jak metoda Main , instrukcje najwyższego poziomu mogą również zwracać wartości i uzyskiwać dostęp do argumentów wiersza polecenia. Aby uzyskać więcej informacji, zobacz Instrukcje najwyższego poziomu. W poniższym przykładzie użyto foreach pętli do wyświetlenia argumentów wiersza polecenia przy użyciu args zmiennej, a na końcu programu zostanie zwrócony kod powodzenia (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;

Począwszy od języka C# 14, programy mogą być aplikacjami opartymi na plikach, gdzie pojedynczy plik zawiera program. Aplikacje oparte na plikach są uruchamiane za pomocą polecenia dotnet run <file.cs>, lub używasz #!/usr/local/share/dotnet/dotnet run dyrektywy jako pierwszego wiersza (tylko powłoki unix).

Omówienie

Main Metoda jest punktem wejściowym programu wykonywalnego; to miejsce, w którym zaczyna się i kończy kontrola programu.
Main należy zadeklarować wewnątrz klasy lub struktury. Otaczanie class może mieć wartość static.
Main musi mieć wartość static.
Main może mieć dowolny modyfikator dostępu (z wyjątkiem file).
Main może mieć typ zwracany: void, int, Task lub Task<int>.
Jeśli i tylko wtedy, gdy Main zwraca wartość Task lub Task<int>, deklaracja Main może zawierać async modyfikator. Ta reguła wyklucza konkretnie metodę async void Main .
Metodę Main można zadeklarować z parametrem lub bez niego, który zawiera string[] argumenty wiersza polecenia. W przypadku tworzenia aplikacji systemu Windows przy użyciu programu Visual Studio można dodać parametr ręcznie lub użyć GetCommandLineArgs() metody w celu uzyskania argumentów wiersza polecenia. Parametry są odczytywane jako argumenty wiersza polecenia z indeksem zerowym. W przeciwieństwie do języka C i C++, nazwa programu nie jest traktowana jako pierwszy argument wiersza polecenia w args tablicy, ale jest to pierwszy element GetCommandLineArgs() metody.

Na poniższej liście przedstawiono najbardziej typowe Main deklaracje:

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

Powyższe przykłady nie określają modyfikatora dostępu, więc są one domyślnie niejawne private . Można określić dowolny jawny modyfikator dostępu.

Napiwek

Dodanie typów zwracania async, Task i Task<int> upraszcza kod programu, gdy aplikacje konsolowe muszą rozpocząć i uruchomić asynchroniczne operacje w await.

Zwracane wartości Main()

Można zwrócić int z metody Main, definiując metodę na jeden z następujących sposobów:

`Main` deklaracja	`Main` kod metody
`static int Main()`	Brak użycia lub `argsawait`
`static int Main(string[] args)`	Używa `args` , ale nie `await`
`static async Task<int> Main()`	Używa `await` , ale nie `args`
`static async Task<int> Main(string[] args)`	Używa `args` i `await`

Jeśli zwracana wartość z Main nie jest używana, zwracanie void lub Task zezwala na nieco prostszy kod.

`Main` deklaracja	`Main` kod metody
`static void Main()`	Brak użycia lub `argsawait`
`static void Main(string[] args)`	Używa `args` , ale nie `await`
`static async Task Main()`	Używa `await` , ale nie `args`
`static async Task Main(string[] args)`	Używa `args` i `await`

Jednak zwraca int lub Task<int> umożliwia programowi przekazywanie informacji o stanie do innych programów lub skryptów, które wywołują plik wykonywalny.

W poniższym przykładzie pokazano, jak można uzyskać dostęp do kodu zakończenia procesu.

W tym przykładzie użyto narzędzi wiersza polecenia platformy .NET Core . Jeśli nie znasz narzędzi wiersza polecenia platformy .NET Core, możesz dowiedzieć się o nich w tym artykule z wprowadzeniem.

Utwórz nową aplikację, uruchamiając polecenie dotnet new console. Zmodyfikuj metodę Main w Program.cs w następujący sposób:

class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

Pamiętaj, aby zapisać ten program jako MainReturnValTest.cs.

Po wykonaniu programu w systemie Windows każda wartość zwracana z Main funkcji jest przechowywana w zmiennej środowiskowej. Tę zmienną środowiskową można pobrać przy użyciu ERRORLEVEL pliku wsadowego lub $LastExitCode programu PowerShell.

Aplikację można skompilować przy użyciu polecenia dotnet CLIdotnet build.

Następnie utwórz skrypt programu PowerShell, aby uruchomić aplikację i wyświetlić wynik. Wklej następujący kod do pliku tekstowego i zapisz go w test.ps1 folderze zawierającym projekt. Uruchom skrypt programu PowerShell, wpisując polecenie test.ps1 w wierszu polecenia programu PowerShell.

Ponieważ kod zwraca zero, plik wsadowy zgłasza powodzenie. Jeśli jednak zmienisz MainReturnValTest.cs, aby zwrócić wartość inną niż zero, a następnie ponownie skompilować program, kolejne wykonanie skryptu programu PowerShell zgłosi błąd.

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

Async Main zwracane wartości

Podczas deklarowania wartości zwracanej async dla Main, kompilator generuje kod szablonowy do wywoływania metod asynchronicznych w Main.

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

    private static async Task<int> AsyncConsoleWork()
    {
        return 0;
    }
}

W obu przykładach główna treść programu znajduje się w treści metody AsyncConsoleWork().

Zaletą deklarowania Main , ponieważ async jest to, że kompilator zawsze generuje prawidłowy kod.

Gdy punkt wejścia aplikacji zwraca Task wartość lub Task<int>, kompilator generuje nowy punkt wejścia, który wywołuje metodę punktu wejścia zadeklarowaną w kodzie aplikacji. Zakładając, że ten punkt wejścia jest nazywany $GeneratedMain, kompilator generuje następujący kod dla tych punktów wejścia:

static Task Main() powoduje, że kompilator emituje odpowiednik wartości private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task Main(string[]) powoduje, że kompilator emituje odpowiednik wartości private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
static Task<int> Main() powoduje, że kompilator emituje odpowiednik wartości private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task<int> Main(string[]) powoduje, że kompilator emituje odpowiednik wartości private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Uwaga

Jeśli w metodzie async użyto Main modyfikatora przykładów, kompilator wygeneruje ten sam kod.

Argumenty wiersza polecenia

Argumenty można wysyłać do Main metody, definiując metodę w jeden z następujących sposobów:

`Main` deklaracja	`Main` kod metody
`static void Main(string[] args)`	Brak zwracanej wartości lub `await`
`static int Main(string[] args)`	Zwraca wartość, ale nie używa `await`
`static async Task Main(string[] args)`	Używa `await` , ale nie zwraca wartości
`static async Task<int> Main(string[] args)`	Zwróć wartość i użyj `await`

Jeśli argumenty nie są używane, możesz pominąć args z deklaracji metody, aby uzyskać nieco prostszy kod.

`Main` deklaracja	`Main` kod metody
`static void Main()`	Brak zwracanej wartości lub `await`
`static int Main()`	Zwraca wartość, ale nie używa `await`
`static async Task Main()`	Używa `await` , ale nie zwraca wartości
`static async Task<int> Main()`	Zwraca wartość i używa `await`

Uwaga

Możesz również użyć polecenia Environment.CommandLine lub Environment.GetCommandLineArgs uzyskać dostęp do argumentów wiersza polecenia z dowolnego punktu w konsoli lub aplikacji Windows Forms. Aby włączyć argumenty wiersza polecenia w deklaracji metody w Main aplikacji Windows Forms, należy ręcznie zmodyfikować deklarację Main. Kod wygenerowany przez projektanta formularzy systemu Windows tworzy Main bez parametru wejściowego.

Parametr Main metody to tablica String reprezentująca argumenty wiersza polecenia. Zazwyczaj określa się, czy argumenty istnieją, testując Length właściwość, na przykład:

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

Napiwek

Tablica args nie może mieć wartości null. Dlatego można bezpiecznie uzyskać dostęp do właściwości bez sprawdzania Length wartości null.

Argumenty ciągu można również przekonwertować na typy liczbowe przy użyciu Convert klasy lub Parse metody. Na przykład następująca instrukcja konwertuje string wartość na long liczbę przy użyciu Parse metody :

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

Można również użyć typu long C#, który aliasuje Int64.

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

Możesz również użyć Convert metody ToInt64 klasy, aby wykonać to samo:

long num = Convert.ToInt64(s);

Aby uzyskać więcej informacji, zobacz Parse i Convert.

Napiwek

Analizowanie argumentów wiersza polecenia może być złożone. Rozważ użycie biblioteki System.CommandLine (obecnie w wersji beta), aby uprościć proces.

W poniższym przykładzie pokazano, jak używać argumentów wiersza polecenia w aplikacji konsolowej. Aplikacja przyjmuje jeden argument w czasie wykonywania, konwertuje argument na liczbę całkowitą i oblicza współczynnik liczby. Jeśli nie podano żadnych argumentów, aplikacja wysyła komunikat wyjaśniający prawidłowe użycie programu.

Aby skompilować i uruchomić aplikację z poziomu wiersza polecenia, wykonaj następujące kroki:

Wklej następujący kod do dowolnego edytora tekstów, a następnie zapisz plik jako plik tekstowy o nazwie 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)
    {
        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;
    }
}

Na początku metody Main program sprawdza, czy argumenty wejściowe nie zostały dostarczone, porównując długość argumentu args z 0, i jeśli nie znaleziono żadnych argumentów, wyświetla pomoc.
Jeśli podano argumenty (args.Length jest większe niż 0), program próbuje przekonwertować argumenty wejściowe na liczby. Ten przykład zgłasza wyjątek, jeśli argument nie jest liczbą.
Po obliczeniu współczynnika (przechowywanego w result zmiennej typu long) pełny wynik jest drukowany w zależności od zmiennej result .

W menu Start lub Start otwórz okno wiersza polecenia dla deweloperów programu Visual Studio, a następnie przejdź do folderu zawierającego utworzony plik.
Aby skompilować aplikację, wprowadź następujące polecenie:

dotnet build

Jeśli aplikacja nie ma błędów kompilacji, zostanie utworzony plik binarny o nazwie Factorial.dll .
Wprowadź następujące polecenie, aby obliczyć współczynnik 3:

dotnet run -- 3
Jeśli wartość 3 zostanie wprowadzona w wierszu polecenia jako argument programu, wyjście pokazuje: The factorial of 3 is 6.

Uwaga

Podczas uruchamiania aplikacji w programie Visual Studio można określić argumenty wiersza polecenia na stronie debugowania, Project Designer.

specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz Specyfikacja języka C#. Specyfikacja języka jest ostatecznym źródłem informacji o składni i użyciu języka C#.

Zobacz też

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-07-01

Udostępnij za pomocą

Main() i argumenty wiersza polecenia

Omówienie

Zwracane wartości Main()

Async Main zwracane wartości

Argumenty wiersza polecenia

specyfikacja języka C#

Zobacz też

Sprzężenie zwrotne

Dodatkowe zasoby