Main() и аргументы командной строки

Метод Main — это точка входа приложения C#. Когда приложение запускается, первым вызывается именно метод Main.

В программе на C# может существовать только одна точка входа. Если у вас есть несколько классов с методом Main, программу нужно компилировать с параметром компилятора StartupObject, чтобы указать, какой из методов Main будет использоваться в качестве точки входа. Дополнительные сведения см. в разделе StartupObject (параметры компилятора C#). В следующем примере отображается число аргументов командной строки в качестве первого действия:

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

Инструкции верхнего уровня можно также использовать в одном файле в качестве точки входа для приложения. Как и метод Main, операторы верхнего уровня могут также возвращать значения и получать доступ к аргументам командной строки. Для получения дополнительной информации, смотрите инструкции верхнего уровня. В следующем примере цикл foreach используется для отображения аргументов командной строки с помощью переменной args, а в конце программы возвращается код успешного выполнения (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;

Начиная с C# 14, программы могут быть файловыми программами, где один файл содержит программу. Вы запускаете программы на основе файлов с помощью команды dotnet run <file.cs>или используете #!/usr/local/share/dotnet/dotnet run директиву в качестве первой строки (только оболочки UNIX).

Обзор

• Метод Main — это точка входа исполняемой программы; это место, где начинается и заканчивается выполнение программы.
• Main должен быть объявлен внутри класса или структуры. Включающее class может быть static.
• Аргумент Main должен иметь значение static.
• Main может иметь любой модификатор доступа (кроме file).
• Main может иметь тип возвращаемого значения: void, int, Task или Task<int>.
• Если и только если Main возвращает Task или Task<int>, объявление Main может включать модификатор async. Это правило специально исключает async void Main метод.
• Метод Main может быть объявлен с параметром string[], который содержит аргументы командной строки, или без него. При использовании Visual Studio для создания приложений Windows можно добавить параметр вручную или использовать GetCommandLineArgs() метод для получения аргументов командной строки. Параметры считываются как аргументы командной строки, индексы которых начинаются с нуля. В отличие от C и C++, имя программы не рассматривается как первый аргумент командной строки в args массиве, но это первый элемент GetCommandLineArgs() метода.

В следующем списке показаны наиболее распространенные Main объявления:

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

В предыдущих примерах не указывается модификатор доступа, поэтому они неявно private по умолчанию. Можно указать любой явный модификатор доступа.

Возвращаемые значения Main()

Вы можете возвратить int из метода Main, определив метод одним из следующих способов:

Если возвращаемое значение из Main не используется, возвращение void или Task допускает немного более простой код.

Однако возврат int или Task<int> позволяет программе передавать информацию о своем состоянии другим программам и скриптам, которые вызывают исполняемый файл.

В следующем примере показано, как можно получить доступ к коду завершения для процесса.

В этом примере используются программы командной строки .NET Core. Если вы не знакомы с инструментами командной строки .NET Core, их можно узнать в этой статье о начале работы.

Создайте приложение, выполнив команду dotnet new console. Измените Main метод в Program.cs следующим образом:

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

Не забудьте сохранить эту программу как MainReturnValTest.cs.

При запуске программы в Windows значение, возвращаемое функцией Main, сохраняется в переменной среды. Эту переменную среды можно получить из пакетного файла с помощью ERRORLEVEL или в PowerShell с помощью $LastExitCode.

Для сборки приложения можно использовать команду dotnet CLIdotnet build.

Затем создайте скрипт PowerShell для запуска приложения и отображения результата. Вставьте следующий код в текстовый файл и сохраните его под именем test.ps1 в папке проекта. Запустите скрипт PowerShell, введя команду test.ps1 в командной строке PowerShell.

Так как код возвращает ноль, пакетный файл сообщает об успешном выполнении. Однако если изменить MainReturnValTest.cs, чтобы вернуть ненулевое значение, а затем перекомпилировать программу, последующее выполнение скрипта PowerShell сообщает о сбое.

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

Значения, возвращаемые асинхронным методом main

При объявлении возвращаемого значения для async компилятор создает стандартный код для вызова асинхронных методов в Main.

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

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

В обоих примерах основная часть программы находится в методе AsyncConsoleWork().

Преимущество объявления Main как async заключается в том, что компилятор всегда генерирует правильный код.

Если точка входа приложения возвращает Task или Task<int>, то компилятор создает новую точку входа, которая вызывает метод точки входа, объявленный в коде приложения. Предположим, что эта точка входа называется $GeneratedMain. В этом случае компилятор создает следующий код для этих точек входа:

• static Task Main() приводит к тому, что компилятор формирует эквивалент private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
• static Task Main(string[]) приводит к тому, что компилятор формирует эквивалент private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
• static Task<int> Main() приводит к тому, что компилятор формирует эквивалент private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
• static Task<int> Main(string[]) приводит к тому, что компилятор формирует эквивалент private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Аргументы командной строки

Вы можете передавать аргументы в метод Main, определив метод одним из следующих способов:

Если аргументы не используются, вы можете исключить args из объявления метода, чтобы код стал немного проще.

Параметр метода Main — это массив String, представляющий аргументы командной строки. Как правило, определить, существуют ли аргументы, можно, проверив свойство Length, например:

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

Строковые аргументы также можно преобразовать в числовые типы с помощью класса Convert или метода Parse. Например, следующая инструкция преобразует string в число long с помощью метода Parse:

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

Можно также использовать тип long, который является псевдонимом для Int64.

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

Также можно использовать метод класса ConvertToInt64 для того же:

long num = Convert.ToInt64(s);

Дополнительные сведения см. в разделах Parse и Convert.

В следующем примере показано использование аргументов командной строки в консольном приложении. Приложение принимает один аргумент времени выполнения, преобразует аргумент в целое число и вычисляет факториал числа. Если не указано никаких аргументов, приложение выдает сообщение, поясняющее правильное использование программы.

Чтобы скомпилировать и запустить приложение из командной строки, выполните следующие действия.

1. Вставьте следующий код в любой текстовый редактор и сохраните файл как текстовый файл с именем 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;
       }
   }
   

   В начале метода Main программа проверяет, были ли предоставлены входные аргументы, сравнивая длину аргумента args с 0 и отображает справку, если аргументы не найдены.
   Если указаны аргументы (args.Length больше 0), программа пытается преобразовать входные аргументы в числа. В этом примере создается исключение, если аргумент не является числом.
   После вычисления факториала (хранящегося в result переменной типа long), подробный результат выводится в зависимости от переменной result .

2. С экрана Пуск или из меню Пуск откройте окно Командной строки разработчика Visual Studio, а затем перейдите в папку, содержащую созданный вами файл.

3. Чтобы скомпилировать приложение, введите следующую команду:

   dotnet build

   Если у приложения нет ошибок компиляции, создается двоичный файл с именемFactorial.dll .

4. Введите приведенную ниже команду для вычисления факториала числа 3:

   dotnet run -- 3

5. Если 3 введено в командной строке в качестве аргумента программы, выходные данные считываются: The factorial of 3 is 6.

Спецификация языка C#

Дополнительные сведения см. в спецификации языка C#. Спецификация языка является авторитетным источником синтаксиса и использования языка C#.

См. также

• System.Environment
• Отображение аргументов командной строки