Partilhar via

Argumentos main() e de linha de comando

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

Só pode haver um ponto de entrada em um programa C#. Se você tiver mais de uma classe que tem um Main método, você deve compilar seu programa com a opção de compilador StartupObject para especificar qual Main método usar como o 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. Assim como o Main método, 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 Declaraçõ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 arquivos, onde 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).

Descriçã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 deve ser declarado dentro de uma classe ou estrutura. O anexo class pode ser static.
  • Main deve ser static.
  • Main pode ter qualquer modificador de acesso (exceto file).
  • Mainpode ter um voidint, , Task, ou Task<int> tipo de retorno.
  • 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.
  • O Main método pode ser declarado com ou sem um string[] parâmetro que contém argumentos de linha de comando. 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 lidos como argumentos de linha de comando 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. É possível especificar qualquer modificador de acesso explícito.

Gorjeta

A adição de async e Task tipos de retorno simplifica o código do programa quando as aplicações de console precisam iniciar operações assíncronas em Task<int>.

Valores de retorno Main()

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

Main Declaração Main código do método
static int Main() Não utilização de args ou await
static int Main(string[] args) Utiliza args mas não await
static async Task<int> Main() Utiliza await mas não args
static async Task<int> Main(string[] args) Utilizações args e await

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

Main Declaração Main código do método
static void Main() Não utilização de args ou await
static void Main(string[] args) Utiliza args mas não await
static async Task Main() Utiliza await mas não args
static async Task Main(string[] args) Utilizações args e await

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 um programa é executado no Windows, qualquer valor retornado da função é armazenado em uma variável de Main ambiente. Essa variável de ambiente pode ser recuperada usando ERRORLEVEL a partir de um ficheiro em lotes, ou $LastExitCode a partir do PowerShell.

Você pode criar 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 digitando test.ps1 no prompt do PowerShell.

Como o código devolve zero, o ficheiro por lotes reporta sucesso. No entanto, se você alterar MainReturnValTest.cs para retornar um valor diferente de zero e, em seguida, recompilar o programa, a execução subsequente do script 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 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á no método AsyncConsoleWork().

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() faz com que o compilador emita 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();
  • static Task<int> Main(string[]) faz com que o compilador emita o equivalente a private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Nota

Se os exemplos usados async modificador no Main método, o compilador iria gerar o mesmo código.

Argumentos de linha de comando

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

Main Declaração Main código do método
static void Main(string[] args) Sem valor de retorno ou await
static int Main(string[] args) Devolve um valor, mas não utiliza await
static async Task Main(string[] args) Usa await , mas não retorna um valor
static async Task<int> Main(string[] args) Retorna um valor e utiliza await

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

Main Declaração Main código do método
static void Main() Sem valor de retorno ou await
static int Main() Devolve um valor, mas não utiliza await
static async Task Main() Usa await , mas não retorna um valor
static async Task<int> Main() Devolve um valor e usa await

Nota

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

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

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

Gorjeta

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

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.

Gorjeta

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

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 método, o programa testa Main se os argumentos de entrada não foram fornecidos, comparando o comprimento do args argumento com 0 e exibe a ajuda se nenhum argumento for encontrado.
    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.

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

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

    dotnet build

    Se seu aplicativo não tiver erros de compilação, um arquivo binário chamado Factorial.dll será criado.

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

    dotnet run -- 3

  5. Se 3 é inserido na linha de comando como argumento do programa, a saída diz: The factorial of 3 is 6.

Nota

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

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

  • Last updated on