Main() i argumenty wiersza polecenia

Artykuł
01/29/2025

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

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żej przedstawiono przykład, w którym pierwszy wiersz wykonany wyświetli liczbę argumentów wiersza polecenia:

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 pętli foreach do wyświetlenia argumentów wiersza polecenia przy użyciu zmiennej args, 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;

Omówienie

Metoda jest punktem wejścia programu wykonywalnego. Jest Main to miejsce, w którym rozpoczyna się i kończy kontrolka 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ć voidtyp , int, Tasklub Task<int> zwracany.
Jeśli i tylko wtedy, gdy Main zwraca wartość Task lub Task<int>, deklaracja Main może zawierać async modyfikator. W szczególności wyklucza to metodę async void Main .
Metodę Main można zadeklarować za pomocą parametru lub bez parametru zawierającego 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 . Jest to typowe, ale można określić dowolny jawny modyfikator dostępu.

Napiwek

Dodanie typów zwracanych async i TaskTask<int>upraszcza kod programu, gdy aplikacje konsolowe muszą uruchamiać i await asynchroniczne operacje w programie Main.

Zwracane wartości Main()

Element z int metody można zwrócićMain, definiując metodę w 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`metody , bez użycia `await`
`static async Task<int> Main()`	Brak użycia elementu `args`, używa `await`
`static async Task<int> Main(string[] args)`	Używa `args` i `await`

Jeśli zwracana wartość z Main nie jest używana, zwracana 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`metody , bez użycia `await`
`static async Task Main()`	Brak użycia elementu `args`, używa `await`
`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łosi 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 Mainprogramu kompilator generuje kod standardowy do wywoływania metod asynchronicznych w programie Main. Jeśli nie określisz słowa kluczowego async , musisz napisać ten kod samodzielnie, jak pokazano w poniższym przykładzie. Kod w przykładzie gwarantuje, że program zostanie uruchomiony do momentu ukończenia operacji asynchronicznej:

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

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

Ten standardowy kod może zostać zastąpiony przez:

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 wartości zwracanej, brak użycia `await`
`static int Main(string[] args)`	Wartość zwracana, brak użycia `await`
`static async Task Main(string[] args)`	Brak wartości zwracanej, używa `await`
`static async Task<int> Main(string[] args)`	Wartość zwracana, używa `await`

Jeśli argumenty nie są używane, można pominąć args deklarację metody dla nieco prostszego kodu:

`Main` deklaracja	`Main` kod metody
`static void Main()`	Brak wartości zwracanej, brak użycia `await`
`static int Main()`	Wartość zwracana, brak użycia `await`
`static async Task Main()`	Brak wartości zwracanej, używa `await`
`static async Task<int> Main()`	Wartość zwracana, 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 longC#, który aliasy 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 tematy Parse oraz 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 wyświetla pomoc, jeśli nie znaleziono argumentów.
Jeśli podano argumenty (args.Length jest większe niż 0) program próbuje przekonwertować argumenty wejściowe na liczby. Spowoduje to zgłoszenie wyjątku, jeśli argument nie jest liczbą.
Po obliczeniu współczynnika (przechowywanego w zmiennej result 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.
Wprowadź następujące polecenie, aby skompilować aplikację.

dotnet build

Jeśli aplikacja nie ma błędów kompilacji, zostanie utworzony plik wykonywalny o nazwie Factorial.exe .
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, dane wyjściowe odczytuje: 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#.

Udostępnij za pośrednictwem

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ż

Dodatkowe zasoby