Parâmetros e Conversão de Dados em C# com VS Code

Objetivo da Aula:

Capacitar os alunos a criar programas C# que interagem com o ambiente, recebendo e processando parâmetros da linha de comando, e a dominar as diversas formas de conversão de dados, incluindo implícita, explícita, System.Convert, e os conceitos de Boxing e Unboxing.

Público-Alvo:

Estudantes de programação com conhecimento básico em C# e uso do VS Code.

Duração Estimada:

1h30min - 2h (dependendo do ritmo dos alunos e da profundidade das discussões/exercícios).

Materiais Necessários:

  • Computadores com Visual Studio Code (VS Code) e SDK do .NET instalados e configurados.

  • Quadro ou lousa para anotações.

Parte 1: Recebimento e Tratamento de Parâmetros (45-60 minutos)

1. Introdução (5 minutos)

  • Professor: "Olá a todos! Hoje vamos aprender como nossos programas C# podem ser mais inteligentes e flexíveis, aceitando informações de fora (parâmetros da linha de comando) e como manipular esses dados (conversões). Isso é super útil para criar ferramentas dinâmicas!"

  • Professor: Perguntar aos alunos: "Alguém já viu programas que vocês executam e podem colocar informações extras depois do nome do programa?" (Ex: git commit -m "minha mensagem"). Explicar que é isso que vamos aprender a fazer.

2. Configurando o Projeto no VS Code (10 minutos - Mão na Massa)

  • Professor: Instruir os alunos a abrir o VS Code.

  • Professor: Abrir o Terminal Integrado (Ctrl+').

  • Professor: Comandos no terminal:

    Bash

    dotnet new console -o ParametroApp
cd ParametroApp
code .

  • Professor: "Lembrem-se, o code . vai reabrir o VS Code na pasta do nosso novo projeto. Isso é muito prático!"

3. Entendendo o Main e os Parâmetros (string[] args) (10 minutos)

  • Professor: Abrir Program.cs.

  • Professor: Explicar a assinatura do método Main: static void Main(string[] args).

    • Focar no string[] args. "Este args é um array de strings, e é para cá que o C# joga todas as palavras que digitarmos depois do nome do nosso programa."

    • Explicar que cada item no array é um parâmetro.

  • Professor: Exemplo Prático (Exibir Parâmetros Simples):

    // Program.cs
namespace ParametroApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            if (args.Length > 0)
            {
                Console.WriteLine("Parâmetros recebidos:");
                for (int i = 0; i < args.Length; i++)
                {
                    Console.WriteLine($"Parâmetro {i + 1}: {args[i]}");
                }
            }
            else
            {
                Console.WriteLine("Nenhum parâmetro foi fornecido.");
                Console.WriteLine("Tente executar o programa com parâmetros, por exemplo:");
                Console.WriteLine("dotnet run -- primeiro segundo terceiro");
            }
        }
    }
}

  • Professor: Execução e Explicação do --:

    • dotnet run (sem parâmetros)

    • dotnet run -- meu parametro de teste (com parâmetros)

    • Crucial: Explicar o --. "Este -- é um separador. Ele diz ao comando dotnet run: 'O que vem depois de mim não é para você, dotnet run, é para o meu programa C#!' Sem ele, o dotnettentaria interpretar 'meu' como uma opção dele mesmo."

4. Tratando Parâmetros: Um Exemplo Prático de Saudações (15-20 minutos)

  • Professor: "Agora que sabemos como receber, vamos aprender a tratar esses parâmetros. Vamos fazer um programa de saudação personalizada!"

  • Professor: Explicar a ideia de "flags" ou "opções" (como -n para nome, -s para saudação).

  • Professor: Código no Program.cs:

    // Program.cs
namespace ParametroApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string nome = "Visitante";
            string saudacaoTipo = "Olá";

            for (int i = 0; i < args.Length; i++)
            {
                if (args[i] == "-n" || args[i] == "--nome")
                {
                    if (i + 1 < args.Length)
                    {
                        nome = args[i + 1];
                        i++; // Avança para pular o valor do nome
                    }
                    else
                    {
                        Console.WriteLine("Erro: O argumento -n ou --nome requer um valor.");
                    }
                }
                else if (args[i] == "-s" || args[i] == "--saudacao")
                {
                    if (i + 1 < args.Length)
                    {
                        saudacaoTipo = args[i + 1];
                        i++; // Avança para pular o valor da saudação
                    }
                    else
                    {
                        Console.WriteLine("Erro: O argumento -s ou --saudacao requer um valor.");
                    }
                }
                else
                {
                    Console.WriteLine($"Aviso: Parâmetro '{args[i]}' não reconhecido.");
                }
            }
            Console.WriteLine($"{saudacaoTipo}, {nome}!");
        }
    }
}

  • Professor: Testes com alunos:

    • dotnet run

    • dotnet run -- -n Alice

    • dotnet run -- -s BoaNoite -n Bob

    • dotnet run -- -n Carla -s Olá

    • dotnet run -- -n David parametro_extra

  • Professor: Reforçar: args.Length, for loop para iterar, tratamento de erro (if (i + 1 < args.Length)).

Parte 2: Conversão de Dados (45-60 minutos)

1. Introdução à Conversão (5 minutos)

  • Professor: "Perfeito! Agora que nossos programas podem receber dados, precisamos saber como transformá-los. E se o usuário digitar '10' como texto e precisarmos somar com outro número? Aí entram as conversões de dados."

  • Professor: "Vamos criar um novo projeto para focar só nisso."

2. Configurando o Novo Projeto de Conversão (5 minutos - Mão na Massa)

  • Professor: No terminal, criar um novo projeto:

    Bash

    cd ..
dotnet new console -o ConversaoDadosApp
cd ConversaoDadosApp
code .

3. Conversão Implícita (10 minutos)

  • Professor: "A conversão implícita é a mais 'tranquila'. Ela acontece automaticamente quando o C# tem certeza que não haverá perda de dados. Pensem em colocar um copo de água num balde: a água cabe, e o balde é maior."

  • Professor: Código no Program.cs:

    // Program.cs
namespace ConversaoDadosApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("--- Conversão Implícita ---");
            int meuInt = 100;
            long meuLong = meuInt; // int para long
            Console.WriteLine($"int para long: {meuInt} -> {meuLong}");

            int outroInt = 250;
            float meuFloat = outroInt; // int para float
            Console.WriteLine($"int para float: {outroInt} -> {meuFloat}");

            float outroFloat = 123.45f;
            double meuDouble = outroFloat; // float para double
            Console.WriteLine($"float para double: {outroFloat} -> {meuDouble}");
            Console.WriteLine("\n--- Fim da Conversão Implícita ---\n");
        }
    }
}

  • Professor: Executar: dotnet run

  • Professor: "Notem que o código funciona sem reclamar. O compilador do C# é inteligente e sabe que long pode guardar qualquer int, por exemplo."

4. Conversão Explícita (Casting) (15 minutos)

  • Professor: "Agora, e se for o contrário? Tentar colocar um balde de água num copo? Aí temos um problema! O compilador não vai fazer isso sozinho, porque pode haver perda de dados. Precisamos dizer a ele explicitamente que estamos cientes do risco, usando o casting."

  • Professor: Código no Program.cs:

    // ... (Manter código anterior ou apagar) ...
Console.WriteLine("--- Conversão Explícita (Casting) ---");
double valorDouble = 9.99;
int valorInt = (int)valorDouble; // double para int (truncamento)
Console.WriteLine($"double para int: {valorDouble} -> {valorInt}");

long numeroLongoGrande = 2147483648L; // Maior que o máximo de int
int numeroInt2 = (int)numeroLongoGrande; // long para int (estouro de inteiro)
Console.WriteLine($"long para int (valor maior): {numeroLongoGrande} -> {numeroInt2}");
Console.WriteLine("Atenção: Houve perda de dados neste caso (estouro de inteiro)!");

char meuChar = 'A';
int charParaInt = (int)meuChar; // char para int (valor ASCII/Unicode)
Console.WriteLine($"char para int: '{meuChar}' -> {charParaInt} (valor ASCII/Unicode)");
Console.WriteLine("\n--- Fim da Conversão Explícita ---\n");

  • Professor: Executar: dotnet run

  • Professor: "Observem a sintaxe (TipoDesejado)variavel. É como se estivéssemos falando: 'Compilador, eu sei o que estou fazendo, pode converter, mesmo que perca dados!' No double para int, a parte decimal é simplesmente cortada. No long para int, se o número for muito grande, ele 'estoura' e vira outro número, que não é o que esperávamos!"

5. Usando System.Convert (15 minutos)

  • Professor: "Quando a gente lida muito com strings (textos) que na verdade representam números, ou precisa de um controle maior sobre as conversões, o System.Convert é nosso melhor amigo. Ele tem métodos específicos para cada tipo e é mais robusto, podendo nos avisar se algo deu errado com exceções."

  • Professor: Código no Program.cs:

    C#

    // ... (Manter código anterior ou apagar) ...
Console.WriteLine("--- Usando System.Convert ---");
string textoNumero = "123";
int numeroConvertido = Convert.ToInt32(textoNumero); // string para int
Console.WriteLine($"string para int: '{textoNumero}' -> {numeroConvertido}");

int outroNumero = 456;
string textoOutroNumero = Convert.ToString(outroNumero); // int para string
Console.WriteLine($"int para string: {outroNumero} -> '{textoOutroNumero}'");

string textoInvalido = "Olá Mundo";
try
{
    int numeroInvalido = Convert.ToInt32(textoInvalido);
}
catch (FormatException)
{
    Console.WriteLine($"Erro: Não foi possível converter '{textoInvalido}' para int. Formato inválido.");
}
Console.WriteLine("\n--- Fim de System.Convert ---\n");

  • Professor: Executar: dotnet run

  • Professor: "Vejam como ele consegue converter de string para número e de número para string. E o mais importante: se a string não for um número válido, ele nos avisa com uma exceção(FormatException), que podemos 'pegar' com um try-catch para que nosso programa não trave."

6. Boxing e Unboxing (15 minutos)

  • Professor: "Esses são conceitos mais avançados, mas muito importantes para entender como C# lida com diferentes tipos de memória. O C# tem tipos de valor (como int, double, bool) que guardam o valor diretamente, e tipos de referência (como string, object, classes) que guardam um endereço para onde o valor está na memória."

  • Professor: Explicar Boxing: "Quando pegamos um tipo de valor e o tratamos como um object (que é um tipo de referência), o C# precisa 'empacotá-lo'. Isso é o Boxing. Ele cria um novo espaço na memória (no 'heap', para referências) e copia o valor para lá."

  • Professor: Código para Boxing:

    C#

    // ... (Manter código anterior ou apagar) ...
Console.WriteLine("--- Boxing ---");
int numeroOriginal = 123;
object objetoBoxed = numeroOriginal; // Boxing: int para object
Console.WriteLine($"Número Original (int): {numeroOriginal}");
Console.WriteLine($"Objeto Boxed (object): {objetoBoxed}");
Console.WriteLine($"Tipo do objeto Boxed: {objetoBoxed.GetType()}");

double pi = 3.14;
object piBoxed = pi; // Boxing de um double
Console.WriteLine($"Valor PI Original (double): {pi}");
Console.WriteLine($"Objeto PI Boxed (object): {piBoxed}");
Console.WriteLine($"Tipo do objeto PI Boxed: {piBoxed.GetType()}");
Console.WriteLine("\n--- Fim do Boxing ---\n");

  • Professor: Executar: dotnet run

  • Professor: Explicar Unboxing: "Agora, se queremos pegar aquele valor que foi 'empacotado' no object e trazê-lo de volta para o seu tipo de valor original, fazemos o Unboxing. Mas cuidado! Para o Unboxing funcionar, você tem que 'desempacotar' para o mesmo tipo que foi empacotado. Se tentar para um tipo diferente, o C# vai reclamar feio!"

  • Professor: Código para Unboxing:

    C#

    // ... (Manter código anterior ou apagar) ...
Console.WriteLine("--- Unboxing ---");
object objetoBoxedInt = 456; // Primeiro, fazemos um boxing
int numeroUnboxed = (int)objetoBoxedInt; // Unboxing: object de volta para int
Console.WriteLine($"Objeto Boxed (int): {objetoBoxedInt}");
Console.WriteLine($"Número Unboxed (int): {numeroUnboxed}");

object objetoBoxedIntParaShort = 99; // Boxeado como int
try
{
    short numeroUnboxedParaShort = (short)objetoBoxedIntParaShort; // ERRO: Tentar unboxar int para short!
}
catch (InvalidCastException ex)
{
    Console.WriteLine($"Erro no Unboxing para tipo diferente: {ex.Message}");
    Console.WriteLine("Você só pode fazer unboxing para o tipo original (int, neste caso).");
}
Console.WriteLine("\n--- Fim do Unboxing ---\n");

  • Professor: Executar: dotnet run

  • Professor: "Prestem atenção ao InvalidCastException. Ele acontece porque, embora short e intsejam números, o Unboxing exige que você volte exatamente para o tipo original que foi boxeado."

Parte 3: Exercício Prático e Discussão (15-20 minutos)

1. Proposta de Exercício (10 minutos)

  • Professor: "Agora é a vez de vocês colocarem a mão na massa e aplicarem tudo o que aprendemos!"

  • Professor: Apresentar o exercício:

    Crie um novo programa de console que:

    1. Declare uma variável decimal com um valor monetário (ex: 150.75m).

    2. Converta esse valor para int usando conversão explícita e mostre o resultado. Peça para eles comentarem a perda de precisão.

    3. Declare uma variável string contendo um número de telefone (ex: "123456789").

    4. Converta essa string para um long usando System.Convert e mostre o resultado.

    5. Tente converter a string "não é um número" para um int usando System.Convert dentro de um bloco try-catch para lidar com a exceção, e exiba uma mensagem de erro amigável se a conversão falhar.

    6. Declare uma variável bool com o valor true.

    7. Faça o boxing dessa variável bool para um object.

    8. Faça o unboxing do object de volta para um bool.

    9. Tente fazer o unboxing do object (que era um bool) para um int dentro de um try-catch e explique a exceção.

2. Discussão e Dúvidas (5-10 minutos)

  • Professor: Abrir para perguntas enquanto os alunos trabalham ou após tentarem resolver o exercício.

  • Professor: Reforçar os cenários de uso para cada tipo de conversão.

    • Implícita: Sempre que for seguro, o C# faz sozinho.

    • Explícita (Casting): Quando o risco de perda de dados é aceitável e você quer forçar a conversão (ex: ignorar decimais).

    • System.Convert: Melhor para conversões de/para strings e para tipos base, com bom controle de erros.

    • Boxing/Unboxing: Para interagir com o tipo object ou coleções que esperam objects (embora genéricos sejam mais recomendados hoje), mas sabendo do impacto no desempenho e da rigidez do unboxing.

AnteriorTratamento de Exceção

Atualizado