Main() e argumentos de linha de comando

O método Main é o ponto de entrada de um aplicativo C#. Quando o aplicativo é iniciado, o método Main é o primeiro método invocado.

Pode haver apenas um ponto de entrada em um programa C#. Se tiver mais de uma classe que tenha um método Main, você deverá compilar seu programa com a opção do compilador StartupObject para especificar qual método Main será usado como ponto de entrada. Para obter mais informações, consulte StartupObject (opções de compilador do C#). O exemplo a seguir exibe o número de argumentos de linha de comando como sua primeira ação:

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

Você também pode usar instruções de nível superior em um arquivo como o ponto de entrada para seu aplicativo. Assim como o método Main, as instruções de nível superior também podem retornar valores e acessar argumentos de linha de comando. Para obter mais informações, consulte Instruções de nível superior. O exemplo a seguir usa um foreach loop para exibir os argumentos de linha de comando usando a args variável e, no final do programa, retorna um código de êxito (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;

A partir do C# 14, os programas podem ser aplicativos baseados em arquivo, em que um único arquivo contém o programa. Você executa aplicativos baseados em arquivo com o comando dotnet run <file.cs> ou usando a #!/usr/local/share/dotnet/dotnet run diretiva como a primeira linha (somente shells Unix).

Visão geral

O Main método é o ponto de entrada de um programa executável; é onde o controle do programa começa e termina.
Main precisa ser declarado dentro de uma classe ou struct. A delimitação class pode ser static.
Main deve ser static.
Main pode ter qualquer modificador de acesso (exceto file).
Main pode ter o tipo de retorno void, int, Task ou Task<int>.
Se e somente se Main retornar um Task ou Task<int>, a declaração de Main pode incluir o async modificador. Essa regra exclui especificamente um async void Main método.
O método Main pode ser declarado com ou sem um parâmetro string[] que contém os argumentos de linha de comando. Ao usar o Visual Studio para criar aplicativos do Windows, você pode adicionar o parâmetro manualmente ou usar o método GetCommandLineArgs() para obter os argumentos de linha de comando. Os parâmetros são lidos como argumentos de linha de comando indexados por zero. Ao contrário de C e C++, o nome do programa não é tratado como o primeiro argumento de linha de comando na args matriz, mas é o primeiro elemento do GetCommandLineArgs() método.

A seguinte lista mostra as declarações Main mais comuns:

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

Os exemplos anteriores não especificam um modificador de acesso, portanto, eles são implicitamente private por padrão. É possível especificar qualquer modificador de acesso explícito.

Dica

A adição dos tipos de retorno async, Task e Task<int> simplifica o código do programa quando os aplicativos do console precisam iniciar e realizar operações assíncronas await no Main.

Valores de retorno de Main()

Você pode retornar um int do método Main ao definir o método de uma das seguintes maneiras:

Declaração `Main`	Código do método `Main`
`static int Main()`	Nenhum uso de `args` ou `await`
`static int Main(string[] args)`	Usa, `args` mas não `await`
`static async Task<int> Main()`	Usa, `await` mas não `args`
`static async Task<int> Main(string[] args)`	Usa `args` e `await`

Se o valor retornado Main não for usado, retornará void ou Task permitirá um código ligeiramente mais simples.

Declaração `Main`	Código do método `Main`
`static void Main()`	Nenhum uso de `args` ou `await`
`static void Main(string[] args)`	Usa, `args` mas não `await`
`static async Task Main()`	Usa, `await` mas não `args`
`static async Task Main(string[] args)`	Usa `args` e `await`

No entanto, o retorno de int ou Task<int> habilita o programa a comunicar informações de status para outros programas ou scripts, que invocam o arquivo executável.

O exemplo a seguir mostra como o código de saída para o processo pode ser acessado.

Este exemplo usa ferramentas de linha de comando do .NET Core. Se você não estiver familiarizado com as ferramentas de linha de comando do .NET Core, poderá aprender sobre elas neste artigo de introdução.

Crie um novo aplicativo ao executar dotnet new console. Modifique o método Main em Program.cs da seguinte maneira:

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

Lembre-se de salvar este programa como MainReturnValTest.cs.

Quando um programa é executado no Windows, qualquer valor retornado da função Main é armazenado em uma variável de ambiente. Essa variável de ambiente pode ser recuperada usando ERRORLEVEL de um arquivo em lotes ou $LastExitCode do PowerShell.

Você pode construir o aplicativo usando o comando dotnet CLIdotnet build.

Em seguida, crie um script do PowerShell para executar o aplicativo e exibir o resultado. Cole o código a seguir em um arquivo de texto e salve-o como test.ps1 na pasta que contém o projeto. Execute o script do PowerShell ao digitar test.ps1 no prompt do PowerShell.

Como o código retorna zero, o arquivo em lote relata êxito. No entanto, se você alterar MainReturnValTest.cs retornar um valor diferente de zero e recompilar o programa, a execução subsequente do script do PowerShell relatará falha.

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

Valores retornados de Async Main

Quando você declara um async valor retornado, Maino compilador gera o código clichê para chamar métodos assíncronos em Main:

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

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

Em ambos os exemplos, o corpo principal do programa está no corpo do método AsyncConsoleWork().

A vantagem de declarar Main como async é que o compilador sempre gera o código correto.

Quando o ponto de entrada do aplicativo retorna um Task ou Task<int>, o compilador gera um novo ponto de entrada que chama o método de ponto de entrada declarado no código do aplicativo. Supondo que esse ponto de entrada é chamado $GeneratedMain, o compilador gera o código a seguir para esses pontos de entrada:

static Task Main() resulta no compilador emitindo o equivalente a private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task Main(string[]) resulta no compilador emitindo o equivalente a private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
static Task<int> Main() resulta no compilador emitindo o equivalente a private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task<int> Main(string[]) resulta no compilador emitindo o equivalente a private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Observação

Se os exemplos usassem o modificador async no método Main, o compilador geraria o mesmo código.

Argumentos de linha de comando

Você pode enviar argumentos para o método Main definindo o método de uma das seguintes maneiras:

Declaração `Main`	Código do método `Main`
`static void Main(string[] args)`	Nenhum valor retornado ou `await`
`static int Main(string[] args)`	Retorna um valor, mas não usa `await`
`static async Task Main(string[] args)`	Usa, `await` mas não retorna um valor
`static async Task<int> Main(string[] args)`	Retornar um valor e usar `await`

Se os argumentos não forem usados, você poderá omitir args da declaração de método para um código ligeiramente mais simples:

Declaração `Main`	Código do método `Main`
`static void Main()`	Nenhum valor retornado ou `await`
`static int Main()`	Retorna um valor, mas não usa `await`
`static async Task Main()`	Usa, `await` mas não retorna um valor
`static async Task<int> Main()`	Retorna um valor e usa `await`

Observação

Você também pode usar Environment.CommandLine ou Environment.GetCommandLineArgs para acessar os argumentos de linha de comando de qualquer ponto em um console ou um aplicativo do Windows Forms. Para habilitar os argumentos de linha de comando na declaração do método Main em um aplicativo do Windows Forms, você precisa modificar manualmente a declaração de Main. O código gerado pelo designer do Windows Forms cria um Main sem um parâmetro de entrada.

O parâmetro do método Main é uma matriz String que representa os argumentos de linha de comando. Geralmente você determina se os argumentos existem testando a propriedade Length, por exemplo:

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

Dica

A matriz args não pode ser nula. Portanto, é seguro acessar a propriedade Length sem verificação de nulos.

Você também pode converter os argumentos de cadeia de caracteres em tipos numéricos, usando a classe Convert ou o método Parse. Por exemplo, a instrução a seguir converte o string em um número long usando o método Parse:

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

Também é possível usar o tipo longC#, que aliases Int64:

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

Você também pode usar o método da classe Convert, o ToInt64, para fazer a mesma coisa:

long num = Convert.ToInt64(s);

Para obter mais informações, consulte Parse e Convert.

Dica

A análise de argumentos de linha de comando pode ser complexa. Considere usar a biblioteca System.CommandLine (atualmente em beta) para simplificar o processo.

O exemplo a seguir mostra como usar argumentos de linha de comando em um aplicativo de console. O aplicativo recebe um argumento em tempo de execução, converte o argumento em um número inteiro e calcula o fatorial do número. Se nenhum argumento for fornecido, o aplicativo emitirá uma mensagem que explica o uso correto do programa.

Para compilar e executar o aplicativo em um prompt de comando, siga estas etapas:

Cole o código a seguir em qualquer editor de texto e, em seguida, salve o arquivo como um arquivo de texto com o nome 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;
    }
}

No início do método, Main o programa testa se argumentos de entrada não foram fornecidos comparando o comprimento do args argumento 0 e exibe a ajuda se nenhum argumento for encontrado.
Se forem fornecidos argumentos (args.Length for maior que 0), o programa tentará converter os argumentos de entrada em números. Este exemplo gera uma exceção se o argumento não for um número.
Depois que o fatorial é calculado (armazenado na result variável do tipo long), o resultado detalhado é impresso dependendo da result variável.

Na tela Inicial ou no menu Iniciar, abra uma janela Prompt de Comando do Desenvolvedor do Visual Studio e, em seguida, navegue até a pasta que contém o arquivo que você acabou de criar.
Para compilar o aplicativo, insira o seguinte comando:

dotnet build

Se o aplicativo não tiver erros de compilação, um arquivo binário chamado Factorial.dll será criado.
Digite o seguinte comando para calcular o fatorial de 3:

dotnet run -- 3
Se 3 for inserido na linha de comando como o argumento do programa, a saída será exibida: The factorial of 3 is 6.

Observação

Ao executar um aplicativo no Visual Studio, você pode especificar argumentos de linha de comando na Página de depuração, Designer de Projeto.

Especificação da linguagem C#

Para obter mais informações, consulte a Especificação da linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Confira também

Comentários

Esta página foi útil?

Last updated on 2025-08-15

Compartilhar via

Main() e argumentos de linha de comando

Visão geral

Valores de retorno de Main()

Valores retornados de Async Main

Argumentos de linha de comando

Especificação da linguagem C#

Confira também

Comentários

Recursos adicionais