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

class TestClass
{
    static void Main(string[] args)
    {
        // Display the number of command line arguments.
        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 Instruções de nível superior.

using System.Text;

StringBuilder builder = new();
builder.AppendLine("The following arguments are passed:");

// Display the command line arguments using the args variable.
foreach (var arg in args)
{
    builder.AppendLine($"Argument={arg}");
}

Console.WriteLine(builder.ToString());

// Return a success code.
return 0;

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. Isto 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. Isso é típico, mas é possível 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 usado, retornando void ou Task permitirá 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 um novo aplicativo executando dotnet new consoleo . Modifique o Main método de Program.cs da seguinte maneira:

// Save this program as MainReturnValTest.cs.
class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

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 um arquivo em lotes ou $LastExitCode o 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 retorna zero, o arquivo em lotes relatará êxito. 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 principais assíncronos

Quando você declara um valor de async retorno para Main, o compilador gera o código clichê para chamar métodos assíncronos em Main. Se você não especificar a palavra-chave async , precisará escrever esse código por conta própria, conforme mostrado no exemplo a seguir. O código no exemplo garante que o programa seja executado até que a operação assíncrona seja concluída:

class AsyncMainReturnValTest
{
    public static int Main()
    {
        return AsyncConsoleWork().GetAwaiter().GetResult();
    }

    private static async Task<int> AsyncConsoleWork()
    {
        // Main body here
        return 0;
    }
}

Este código clichê pode ser substituído por:

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

    private static async Task<int> AsyncConsoleWork()
    {
        // main body here 
        return 0;
    }
}

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();

Argumentos de linha de comando

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

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:

O parâmetro do método é uma String matriz que representa os argumentos de linha de Main 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;
}

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 longC#, que aliases Int64:

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

Você também pode usar o Convert método ToInt64 class 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)
       {
           // Test if input arguments were supplied.
           if (args.Length == 0)
           {
               Console.WriteLine("Please enter a numeric argument.");
               Console.WriteLine("Usage: Factorial <num>");
               return 1;
           }
   
           // Try to convert the input arguments to numbers. This will throw
           // an exception if the argument is not a number.
           // num = int.Parse(args[0]);
           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;
           }
   
           // Calculate factorial.
           long result = Functions.Factorial(num);
   
           // Print result.
           if (result == -1)
               Console.WriteLine("Input must be >= 0 and <= 20.");
           else
               Console.WriteLine($"The Factorial of {num} is {result}.");
   
           return 0;
       }
   }
   // If 3 is entered on command line, the
   // output reads: The factorial of 3 is 6.
   

2. Na tela Iniciar ou no menu Iniciar, abra uma janela do Prompt de Comando do Visual Studio Developer e navegue até a pasta que contém o arquivo que você criou.

3. Digite o seguinte comando para compilar o aplicativo.

   dotnet build

   Se seu aplicativo não tiver erros de compilação, um arquivo executável chamado Fatorial.exe será criado.

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

   dotnet run -- 3

5. O comando produz esta saída: 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