Argumentos de linha de comando em aplicações C# em 10 minutos ou menos

O que são argumentos de linha de comando?

No início, Tim explica por que os argumentos da linha de comando são importantes. Ele compara isso à forma como iniciamos ferramentas como o Docker, onde especificamos comandos como qual imagem carregar ou qual tarefa executar. Da mesma forma, em aplicativos de linha de comando C#, você pode passar parâmetros que definem o comportamento do programa em tempo de execução.

Por exemplo, se você estivesse executando um aplicativo de console para processar arquivos, talvez quisesse especificar o caminho do arquivo ou o modo por meio da entrada da linha de comando, em vez de modificar o código.

Configurando o projeto do console

Tim começa no Visual Studio com um projeto básico de Aplicativo de Console .NET 8. O código padrão apenas imprime uma mensagem como "Pressione Enter para sair", usando uma instrução Console.ReadLine() para aguardar a entrada do usuário antes de fechar.

Agora, para lidar com a entrada pela linha de comando, Tim apresenta o array args, que armazena os argumentos passados ​​para o aplicativo quando executado. Embora os aplicativos de console C# modernos usem instruções de nível superior, nos bastidores eles ainda possuem um ponto de entrada definido como:

static void Main(string[] args)

static void Main(string[] args)

ou às vezes:

static int Main(string[] args)

static int Main(string[] args)

Essas assinaturas representam o método principal - o ponto de entrada onde a execução começa. O parâmetro args é uma matriz de strings (string[]), contendo todos os argumentos fornecidos pela linha de comando.

Tim demonstra a iteração sobre o array args usando um loop foreach:

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

Aqui, var arg representa cada argumento de string na matriz args, e o programa os exibe em linhas separadas na saída do console.

Tim observa que, embora as instruções de nível superior ocultem o código repetitivo, como a classe Program e o método Main, tudo continua funcionando da mesma forma: o array args está sempre disponível e pronto para capturar argumentos da linha de comando.

Executando o aplicativo de console

Em seguida, Tim mostra como testar esse recurso. Executar o programa normalmente dentro do Visual Studio não mostrará nenhuma diferença, já que nenhuma entrada de linha de comando foi fornecida.

Para testar corretamente, ele modifica manualmente o processo de execução: abre o Explorador de Arquivos, navega até a pasta bin → Debug → net8.0 do projeto e inicia uma janela de terminal a partir desse caminho.

A partir daí, ele usa o seguinte comando:

ConsoleArgs.exe "hello world" -t timing

ConsoleArgs.exe "hello world" -t timing

Este comando demonstra vários pontos-chave:

• A expressão "hello world" entre aspas é tratada como um único argumento de string, e não como duas palavras separadas.

• A flag -t e a palavra timing são tratadas como dois argumentos adicionais.

Ao executar o comando, a saída do console mostra:

hello world  
-t  
timing

hello world  
-t  
timing

Cada argumento de linha representa um elemento na matriz args. Tim explica que isso confirma o uso correto dos argumentos da linha de comando - o aplicativo de console recebeu e exibiu com sucesso todos os argumentos passados ​​durante a execução.

Ele menciona que os desenvolvedores também podem usar o comando dotnet run em vez do caminho do executável ao executar o programa a partir de um diretório de projeto:

dotnet run -- "hello world" -t timing

dotnet run -- "hello world" -t timing

O hífen duplo (--) indica ao .NET que tudo o que vem depois dele deve ser tratado como parâmetros da linha de comando do seu programa, e não da própria CLI do .NET .

Manipulação e análise de argumentos da linha de comando

Agora que podemos ler argumentos, Tim discute como lidar de forma inteligente com argumentos de linha de comando.

Por exemplo, se -t for uma opção que espera um valor, o programa deve saber que deve tratar o próximo argumento de string como seu valor. Tim mostra que você pode analisar isso manualmente verificando os índices na matriz de argumentos:

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

Essa abordagem permite lidar com argumentos nomeados, tipos numéricos e até mesmo sinalizadores de modo detalhado. Tim observa que os desenvolvedores costumam usar uma instrução switch ou até mesmo documentação e bibliotecas externas para análises de argumentos mais avançadas, mas o namespace System e o array args já fornecem tudo o que é necessário para casos básicos.

Estendendo para um aplicativo Windows Forms

Após demonstrar aplicativos de console, Tim passa para um aplicativo Windows Forms (WinForms).

No código gerado, o arquivo Program.cs contém um método estático void Main(), mas ele ainda não aceita parâmetros. Para habilitar argumentos de linha de comando, Tim modifica manualmente o método Main para incluir o parâmetro args:

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

Ele explica que args.FirstOrDefault() recupera o primeiro parâmetro de entrada da matriz args (ou retorna "default" se nenhum argumento for fornecido).

Em seguida, na classe Form1, Tim atualiza o construtor para aceitar um argumento do tipo string:

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

Aqui, displayName é um rótulo definido no Designer de Formulários do Windows, e agora exibe o argumento passado pela linha de comando.

Quando ele executa o programa sem argumentos, o rótulo exibe "padrão". Quando ele o executa novamente com:

WinFormsArgs.exe "Hello World"

WinFormsArgs.exe "Hello World"

A janela do formulário exibe "Olá Mundo".

Tim explica que essa técnica permite que os aplicativos Windows Forms suportem argumentos de linha de comando, assim como os aplicativos de console, dando aos usuários a capacidade de alterar o comportamento de inicialização dinamicamente.

Usos práticos de argumentos de linha de comando (7:18)

Tim conclui discutindo o quão versáteis as ferramentas de linha de comando podem se tornar com esse recurso. Os desenvolvedores podem usar argumentos de linha de comando para:

Inicie aplicativos em modos diferentes (por exemplo, modo escuro versus modo claro*).

• Forneça os caminhos dos arquivos ou as opções de configuração na inicialização.

• Ative o modo detalhado ou os recursos de depuração usando opções simples como -v ou --debug.

• Crie atalhos que passem argumentos específicos para diferentes fluxos de trabalho.

Ao projetar o método principal para aceitar argumentos do tipo string, você pode facilmente ampliar a flexibilidade e a adaptabilidade do seu aplicativo, sem a necessidade de diálogos de entrada de usuário adicionais ou arquivos de configuração.

Conclusão (8:15)

Sua explicação baseada em exemplos mostra que lidar com argumentos de linha de comando em C# não é complicado - trata-se simplesmente de entender que toda aplicação tem um ponto de entrada (Main) onde os argumentos passados ​​pela linha de comando chegam como uma matriz de strings.

Quer você esteja trabalhando com aplicativos de console ou aplicativos Windows Forms, esse conceito permite que seus programas respondam dinamicamente a comandos, valores e parâmetros especificados na inicialização.

Conclusão final

O vídeo de Tim Corey oferece um guia claro e prático para o uso correto de argumentos de linha de comando em C#. Ao entender como o parâmetro args funciona no método Main, os desenvolvedores podem facilmente criar, analisar e usar argumentos para aplicações mais robustas e configuráveis.

Portanto, da próxima vez que você criar um projeto em C#, lembre-se de que os argumentos da linha de comando não são apenas sintaxe técnica — eles são a ponte entre o seu programa e os usuários, dando ao seu código mais poder, flexibilidade e usabilidade no mundo real.