Main() i argumenty wiersza polecenia

Metoda Main jest punktem wejścia aplikacji języka C#. (Biblioteki i usługi nie wymagają Main metody jako punktu wejścia). 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 jest deklarowany wewnątrz klasy lub struktury. Main musi być static i nie musi być public. (We wcześniejszym przykładzie otrzymuje on domyślny dostęp do privatepliku ). Elementem otaczającym class może być static.
• 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.

Poniższa lista zawiera prawidłowe 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) { }

W powyższych przykładach wszystkie używają public modyfikatora dostępu. Jest to typowe, ale nie jest wymagane.

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:

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

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 void Main()
    {
        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();

Argumenty wiersza polecenia

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

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

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;
}

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.

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:

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

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

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

4. Wprowadź następujące polecenie, aby obliczyć współczynnik 3:

   dotnet run -- 3

5. Polecenie generuje następujące dane wyjściowe: The factorial of 3 is 6.

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ż

• System.Environment
• Jak wyświetlić argumenty wiersza polecenia