Argumentos main() e de linha de comando
O Main
método é o ponto de entrada de um aplicativo C#. (Bibliotecas e serviços não exigem um Main
método como ponto de entrada.) 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
é declarado dentro de uma classe ou struct.Main
deve serstatic
e não precisa serpublic
. (No exemplo anterior, ele recebe o acesso padrão deprivate
.) Um anexoclass
pode serstatic
.Main
pode ter umvoid
int
, ,Task
, ouTask<int>
tipo de retorno.- Se e somente se
Main
retornar aTask
ouTask<int>
, a declaração deMain
pode incluir oasync
modificador. Isto exclui especificamente umasync void Main
método. - O
Main
método pode ser declarado com ou sem umstring[]
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 naargs
matriz, mas é o GetCommandLineArgs() primeiro elemento do método.
A lista a seguir mostra assinaturas válidas Main
:
public static void Main() { }
public static int Main() { }
public static void Main(string[] args) { }
public static int Main(string[] args) { }
public static async Task Main() { }
public static async Task<int> Main() { }
public static async Task Main(string[] args) { }
public static async Task<int> Main(string[] args) { }
Todos os exemplos anteriores usam o modificador de public
acessador. Isso é típico, mas não obrigatório.
A adição de e Task
, Task<int>
tipos de retorno simplifica o código do programa quando os aplicativos de async
console precisam iniciar e await
operações assíncronas no Main
.
Valores de retorno Main()
Você pode retornar um int
do Main
método definindo o método de uma das seguintes maneiras:
Main código do método |
Main assinatura |
---|---|
Não utilização de args ou await |
static int Main() |
Utilizações args , não utilização de await |
static int Main(string[] args) |
Não utilização de , utilizações args await |
static async Task<int> Main() |
Utilizações args e await |
static async Task<int> Main(string[] args) |
Se o valor de retorno de Main
não for usado, retornando void
ou Task
permitirá um código um pouco mais simples.
Main código do método |
Main assinatura |
---|---|
Não utilização de args ou await |
static void Main() |
Utilizações args , não utilização de await |
static void Main(string[] args) |
Não utilização de , utilizações args await |
static async Task Main() |
Utilizações args e await |
static async Task Main(string[] args) |
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 console
o . 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 void Main()
{
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 aprivate static void $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task Main(string[])
faz com que o compilador emita o equivalente aprivate static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
static Task<int> Main()
faz com que o compilador emita o equivalente aprivate static int $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task<int> Main(string[])
faz com que o compilador emita o equivalente aprivate 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 código do método |
Main assinatura |
---|---|
Sem valor de retorno, sem uso de await |
static void Main(string[] args) |
Valor de retorno, sem uso de await |
static int Main(string[] args) |
Sem valor de retorno, usa await |
static async Task Main(string[] args) |
Valor de retorno, usa await |
static async Task<int> Main(string[] args) |
Se os argumentos não forem usados, você pode omitir args
da assinatura do método para um código um pouco mais simples:
Main código do método |
Main assinatura |
---|---|
Sem valor de retorno, sem uso de await |
static void Main() |
Valor de retorno, sem uso de await |
static int Main() |
Sem valor de retorno, usa await |
static async Task Main() |
Valor de retorno, usa await |
static async Task<int> Main() |
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
assinatura de método em um aplicativo do Windows Forms, você deve modificar manualmente a assinatura de Main
. O código gerado pelo designer do Windows Forms é criado Main
sem um parâmetro de entrada.
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;
}
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
C#, 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.
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:
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.
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.
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.
Digite o seguinte comando para calcular o fatorial de 3:
dotnet run -- 3
O comando produz esta saída:
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
Comentários
https://aka.ms/ContentUserFeedback.
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja:Submeter e ver comentários