Main() i argumenty wiersza polecenia

Artykuł
06/22/2024

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

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

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;

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 Task<int> Taskupraszcza kod programu, gdy aplikacje konsolowe muszą uruchamiać i await asynchroniczne operacje w programie Main.

Zwracane wartości Main()

Element z Main metody można zwrócićint, 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:

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

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()
    {
        // Main body here
        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()
    {
        // main body here 
        return 0;
    }
}

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 Main użyto async 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)
    {
        // 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.

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
Polecenie generuje następujące dane wyjściowe: 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