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

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

Программа 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 <file.cs>или с помощью #!/usr/bin/env dotnet run директивы в качестве первой строки (только оболочки Unix).

Обзор

Метод Main — это точка входа исполняемой программы. Это место, где начинается и заканчивается управление программой.
Необходимо объявить Main внутри класса или структуры. Включающее class может быть static.
Аргумент Main должен иметь значение static.
Main может иметь любой модификатор доступа.
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 по умолчанию. Можно указать любой явный модификатор доступа.

Совет

Используя возвращаемые типы async, Task или Task<int>, вы упрощаете программный код, когда консольным приложениям необходимо запускать и выполнять асинхронные операции в Main.

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

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

`Main` декларация	Код метода `Main`
`static int Main()`	Без использования `args` или `await`
`static int Main(string[] args)`	Используется `args`, но не `await`
`static async Task<int> Main()`	Используется `await`, но не `args`
`static async Task<int> Main(string[] args)`	С использованием `args` и `await`

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

`Main` декларация	Код метода `Main`
`static void Main()`	Без использования `args` или `await`
`static void Main(string[] args)`	Используется `args`, но не `await`
`static async Task Main()`	Используется `await`, но не `args`
`static async Task Main(string[] args)`	С использованием `args` и `await`

Однако возврат 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 пакетного файла или $LastExitCode из PowerShell.

Вы можете создать приложение с помощью команды 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();.

Примечание.

Если в примерах используется async модификатор Main метода, компилятор создает тот же код.

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

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

`Main` декларация	Код метода `Main`
`static void Main(string[] args)`	Нет возвращаемого значения или `await`
`static int Main(string[] args)`	Возвращает значение, но не использует `await`
`static async Task Main(string[] args)`	Использует `await`, но не возвращает значение
`static async Task<int> Main(string[] args)`	Возвращает значение и использует `await`

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

`Main` декларация	Код метода `Main`
`static void Main()`	Нет возвращаемого значения или `await`
`static int Main()`	Возвращает значение, но не использует `await`
`static async Task Main()`	Использует `await`, но не возвращает значение
`static async Task<int> Main()`	Возвращает значение и использует `await`

Примечание.

Вы также можете использовать Environment.CommandLine или Environment.GetCommandLineArgs получать доступ к аргументам командной строки из любой точки в консоли или приложении Windows Forms. Чтобы включить аргументы командной строки в объявлении метода в Main приложении Windows Forms, необходимо вручную изменить объявление Main. Код, созданный конструктором Windows Forms, создает Main без входного параметра.

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

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

Совет

Массив args не может иметь значение NULL. Поэтому доступ к свойству Length можно получить без проверки значения NULL.

Строковые аргументы также можно преобразовать в числовые типы с помощью класса 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.

Совет

Анализ аргументов командной строки может быть сложным. Рекомендуется использовать библиотеку System.CommandLine (в настоящее время в бета-версии), чтобы упростить процесс.

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

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

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

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

dotnet build

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

dotnet run -- 3
Если ввести 3 в командной строке в качестве аргумента программы, вывод будет следующим: The factorial of 3 is 6.

Примечание.

При запуске приложения в Visual Studio укажите аргументы командной строки на странице отладки конструктора проектов.

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

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

См. также

Обратная связь

Были ли сведения на этой странице полезными?

Last updated on 2025-12-15

Поделиться через

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

Обзор

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

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

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

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

См. также

Обратная связь

Дополнительные ресурсы