Argumentos main() e de linha de comando

O runtime chama o Main método quando inicias uma aplicação em C#. O Main método é o ponto de entrada de um aplicativo C#.

Um programa de C# só pode ter um ponto de entrada. Se tiver mais do que uma classe com um Main método, deve usar a opção compilador StartupObject ao compilar o seu programa para especificar qual Main o método que serve como ponto de entrada. Para obter mais informações, consulte StartupObject (C# Compiler Options). 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. Tal como o Main método, as instruções de topo podem devolver valores e aceder a argumentos da linha de comandos. Para obter mais informações, consulte Declarações de nível superior. O exemplo seguinte usa um foreach ciclo para mostrar os argumentos da linha de comandos usando a args variável, e no final do programa retorna um código de sucesso (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 arquivos, onde um único arquivo contém o programa. Executa aplicações baseadas em ficheiros usando o comando dotnet <file.cs>, ou usando a #!/usr/bin/env dotnet run diretiva como primeira linha (apenas shells Unix).

Descrição geral

• O Main método é o ponto de entrada de um programa executável. É onde o controlo do programa começa e termina.
• Deve declarar-se Main numa classe ou estrutura. O anexo class pode ser static.
• Main deve ser static.
• Main Pode ter qualquer modificador de acesso.
• Main pode devolver void, int, Task, ou Task<int>.
• Se e somente se Main retornar a Task ou Task<int>, a declaração de Main pode incluir o async modificador. Esta regra exclui especificamente um async void Main método.
• Pode declarar o Main método com ou sem um string[] parâmetro que contenha argumentos de linha de comandos. Ao usar o Visual Studio para criar aplicativos do Windows, você pode adicionar o parâmetro manualmente ou então usar o GetCommandLineArgs() método para obter os argumentos de linha de comando. Os parâmetros são argumentos de linha de comandos indexados a 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 GetCommandLineArgs() primeiro elemento do método.

A lista a seguir mostra as declarações mais comuns 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) { }

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

Valores de retorno Main()

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

Se o valor de retorno de Main não for utilizado, retornar void ou Task permite um código um pouco mais simples.

No entanto, retornar int ou Task<int> permite que o programa comunique 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 do 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 uma nova aplicação executando dotnet new console. Modifique o Main método de Program.cs da seguinte maneira:

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

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

Quando executa um programa no Windows, o sistema armazena qualquer valor devolvido pela Main função numa variável de ambiente. Pode recuperar esta variável de ambiente usando ERRORLEVEL a partir de um ficheiro batch ou $LastExitCode do PowerShell.

Podes construir a aplicação 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 digitando test.ps1 no prompt do PowerShell.

Como o código devolve zero, o ficheiro por lotes reporta sucesso. No entanto, se alterar MainReturnValTest.cs para devolver um valor diferente de zero e depois recompilar o programa, a execução subsequente do script PowerShell reporta 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 de retorno de Async Main

Quando se declara um valor de async retorno para Main, o compilador gera o código padrão 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á dentro do corpo do AsyncConsoleWork() método.

Uma 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 seja chamado $GeneratedMain, o compilador gera o seguinte código para esses pontos de entrada:

• static Task Main() resulta no compilador emitir o equivalente a private static void $GeneratedMain() => Main().GetAwaiter().GetResult();.
• static Task Main(string[]) faz com que o compilador emita o equivalente a private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();.
• static Task<int> Main() faz com que o compilador emita o equivalente a private static int $GeneratedMain() => Main().GetAwaiter().GetResult();.
• O uso de static Task<int> Main(string[]) resulta no compilador emitir o equivalente a private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();.

Argumentos de linha de comando

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

Se não usares os argumentos, podes omitir args da declaração do método para um código ligeiramente mais simples:

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

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

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

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

Também é possível usar o tipo long de C#, que é um apelido para Int64:

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

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

long num = Convert.ToInt64(s);

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

O exemplo a seguir mostra como usar argumentos de linha de comando em um aplicativo de console. O aplicativo usa um argumento em tempo de execução, converte o argumento em um 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 a aplicação a partir de uma linha de comandos, siga estes passos:

1. 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 Fatorial.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 Main método, o programa testa se os argumentos de entrada não foram fornecidos, comparando o comprimento do args argumento com 0 e apresenta a ajuda se não forem encontrados argumentos.
Se os argumentos são fornecidos (args.Length é maior que 0), o programa tenta converter os argumentos de entrada em números. Este exemplo lança uma exceção se o argumento não for um número.
Após o cálculo fatorial (armazenado na variável result do tipo long), o resultado detalhado é impresso dependendo da variável result.

1. No ecrã Iniciar ou no menu Iniciar, abra uma janela do Prompt de Comando de Desenvolvedor do Visual Studio e navegue até à pasta que contém o ficheiro que criou.

2. Para compilar o aplicativo, digite o seguinte comando:

   dotnet build

   Se a sua aplicação não apresentar erros de compilação, o processo de compilação cria um ficheiro binário chamado Factorial.dll.

3. Digite o seguinte comando para calcular o fatorial de 3:

   dotnet run -- 3

4. Se introduzires 3 na linha de comandos como argumento do programa, a saída diz: The factorial of 3 is 6.

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 do C#.

Consulte também

• System.Environment
• Como exibir argumentos de linha de comando