Aula 1: Fundamentos da Programação em C##

Clique aqui para ter acesso completo pelo navegador.

Objetivo:#

Vamos Estabelecer uma base sólida em programação com C#, abordando conceitos fundamentais como variáveis, estruturas de controle, funções e classes.

1. Introdução ao C# e ao .NET Framework#

O que é C#?#

C# é uma linguagem de programação orientada a objetos criada pela Microsoft. Ela é usada para desenvolver uma ampla gama de aplicativos, incluindo sistemas desktop, web e mobile. A linguagem foi projetada para ser simples, moderna e segura, facilitando o desenvolvimento de aplicações robustas.

História e Evolução:#

C# foi lançado em 2000 junto com o .NET Framework. Desde então, passou por várias atualizações, adicionando recursos modernos e poderosos. A combinação de C# com o .NET Framework oferece uma plataforma rica para o desenvolvimento de aplicações.

Arquitetura do .NET Framework:#

O .NET Framework fornece dois componentes principais:

• Common Language Runtime (CLR): Gerencia a execução de programas e oferece serviços como gerenciamento de memória, segurança e tratamento de exceções.
• Base Class Library (BCL): Uma vasta biblioteca de classes que oferece suporte a operações comuns, como entrada/saída, manipulação de dados e gráficos.

2. Ambiente de Desenvolvimento Visual Studio#

O Visual Studio é um IDE poderoso e versátil, ideal para o desenvolvimento de diversas aplicações, como desktop, web e mobile. Ele oferece uma interface personalizável, suporte a várias linguagens de programação, e ferramentas robustas de depuração. Com integração para controle de versão e o Azure, é uma escolha completa para desenvolvedores. A vasta comunidade e o suporte a extensões garantem que o Visual Studio atenda tanto iniciantes quanto profissionais experientes, proporcionando eficiência em todo o ciclo de desenvolvimento.

Configuração inicial:#

1. Crie um novo projeto em C#:

   • Tipo de projeto: Console Application.
   • Nome do projeto: PrimeiroProjeto.

2. Estrutura básica do projeto:

   • O projeto contém arquivos como Program.cs que é o ponto de entrada do programa.

Explorando o Ambiente do Visual Studio:#

• Solution Explorer: Exibe os arquivos e pastas do projeto.
• Editor de Código: Onde o código é escrito e editado.
• Janela de Saída: Mostra mensagens de erro e resultados de build.

Primeiro Programa em C#:#

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

Explicação:

• using System;: Importa o namespace System, que contém classes básicas como Console.
• class Program { }: Define uma classe chamada Program.
• static void Main(): Método principal onde o programa começa a executar.
• Console.WriteLine("Hello, World!");: Exibe a mensagem “Hello, World!” no console.

3. Manipulação de Dados em C##

Variáveis#

Definição de Variável:#

Uma variável é uma área de armazenamento que pode conter dados e cujo valor pode ser modificado durante a execução do programa. As variáveis são usadas para armazenar informações temporárias que podem ser alteradas conforme necessário.

Tipos de Variáveis:#

1. Tipos Primitivos:

   • int: Armazena números inteiros.
   • double: Armazena números de ponto flutuante (decimais).
   • char: Armazena um único caractere.
   • bool: Armazena valores booleanos (true ou false).
   • string: Armazena uma sequência de caracteres (texto).

2. Tipos Referência:

   • object: A classe base para todos os tipos em C#. Pode armazenar qualquer tipo de dado.
   • List<T>: Armazena uma coleção de objetos do tipo T.

Sintaxe Básica para Declaração de Variáveis:#

tipo nome_da_variavel = valor;

Exemplo:

int idade = 25;
double preco = 19.99;
char letra = 'A';
bool ativo = true;
string nome = "João";

Exemplo Detalhado:#

using System;

class Program
{
    static void Main()
    {
        // Declaração e inicialização de variáveis
        int idade = 30;
        double salario = 3500.75;
        char inicial = 'J';
        bool isAtivo = true;
        string nomeCompleto = "Maria Silva";

        // Uso das variáveis
        Console.WriteLine($"Nome: {nomeCompleto}");
        Console.WriteLine($"Idade: {idade}");
        Console.WriteLine($"Salário: {salario:C}");
        Console.WriteLine($"Inicial: {inicial}");
        Console.WriteLine($"Ativo: {isAtivo}");
    }
}

Constantes#

Definição de Constante:#

Uma constante é um valor que não pode ser alterado após a sua definição. Constantes são usadas para armazenar valores que permanecem fixos durante a execução do programa.

Sintaxe Básica para Declaração de Constantes:#

const tipo nome_da_constante = valor;

Requisitos para Constantes:#

• Devem ser inicializadas no momento da declaração.
• O valor não pode ser alterado após a inicialização.

Exemplo Detalhado:#

using System;

class Program
{
    // Declaração de constantes
    const double TAXA_IVA = 0.23; // 23% de IVA
    const int ANO_ATUAL = 2024;

    static void Main()
    {
        // Uso das constantes
        double precoProduto = 100.00;
        double precoComImposto = precoProduto * (1 + TAXA_IVA);
        
        Console.WriteLine($"Preço do produto: {precoProduto:C}");
        Console.WriteLine($"Preço com imposto: {precoComImposto:C}");
        Console.WriteLine($"Ano Atual: {ANO_ATUAL}");
    }
}

Comparação entre Variáveis e Constantes:#

Listas em C##

Definição de Lista:#

Uma lista é uma coleção genérica que pode armazenar uma série de objetos do mesmo tipo. Ao contrário dos arrays, as listas podem crescer e diminuir dinamicamente, oferecendo maior flexibilidade para manipulação de dados.

Características das Listas:#

• Redimensionável: Pode aumentar ou diminuir de tamanho conforme a necessidade.
• Armazenamento de Tipos: Pode armazenar qualquer tipo de dado ou objeto.
• Indexação: Acessa os elementos por índice, começando do zero.

Tipos de Listas:#

• List<T>: Uma lista genérica que pode armazenar objetos de qualquer tipo especificado.

Sintaxe Básica para Declaração e Inicialização de Listas:#

List<tipo> nome_da_lista = new List<tipo>();

Operações Comuns com Listas:#

1. Adicionar Itens:

   nome_da_lista.Add(item);

2. Remover Itens:

   nome_da_lista.Remove(item);
   nome_da_lista.RemoveAt(indice); // Remove pelo índice

3. Acessar Itens:

   var item = nome_da_lista[indice];

4. Iterar Sobre a Lista:

   foreach (var item in nome_da_lista)
   {
       // Código para processar cada item
   }

5. Buscar Itens:

   bool existe = nome_da_lista.Contains(item);
   int indice = nome_da_lista.IndexOf(item);

Exemplo Detalhado:#

Aqui está um exemplo que demonstra como criar e manipular uma lista em C#:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Declaração e inicialização da lista
        List<string> frutas = new List<string>();

        // Adicionar itens à lista
        frutas.Add("Maçã");
        frutas.Add("Banana");
        frutas.Add("Laranja");

        // Acessar e exibir um item da lista
        Console.WriteLine($"Primeira fruta: {frutas[0]}");

        // Iterar sobre a lista e exibir todos os itens
        Console.WriteLine("Lista de frutas:");
        foreach (var fruta in frutas)
        {
            Console.WriteLine(fruta);
        }

        // Remover um item da lista
        frutas.Remove("Banana");

        // Verificar se um item existe na lista
        bool temLaranja = frutas.Contains("Laranja");
        Console.WriteLine($"Tem Laranja? {temLaranja}");

        // Buscar o índice de um item
        int indiceLaranja = frutas.IndexOf("Laranja");
        Console.WriteLine($"Índice da Laranja: {indiceLaranja}");

        // Remover um item pelo índice
        frutas.RemoveAt(indiceLaranja);

        // Exibir a lista após as remoções
        Console.WriteLine("Lista de frutas após remoções:");
        foreach (var fruta in frutas)
        {
            Console.WriteLine(fruta);
        }
    }
}

Explicação do Exemplo:#

1. Criação da Lista:

   • List<string> frutas = new List<string>();: Cria uma lista chamada frutas para armazenar strings.

2. Adição de Itens:

   • frutas.Add("Maçã");: Adiciona um item à lista.

3. Acesso a Itens:

   • Console.WriteLine(frutas[0]);: Acessa o primeiro item da lista.

4. Iteração:

   • foreach (var fruta in frutas): Itera sobre cada item na lista e o exibe.

5. Remoção de Itens:

   • frutas.Remove("Banana");: Remove um item específico da lista.
   • frutas.RemoveAt(indiceLaranja);: Remove um item pelo índice.

6. Verificação e Busca:

   • bool temLaranja = frutas.Contains("Laranja");: Verifica se um item está presente na lista.
   • int indiceLaranja = frutas.IndexOf("Laranja");: Obtém o índice de um item.

4. Operadores Aritméticos e Lógicos em C##

Operadores Aritméticos#

Os operadores aritméticos são usados para realizar operações matemáticas básicas. Aqui está uma lista dos operadores aritméticos disponíveis em C#:

1. Adição (+):

   • Uso: Soma dois operandos.
   • Sintaxe: operando1 + operando2
   • Exemplo:

     int a = 5;
     int b = 10;
     int soma = a + b; // soma é 15

2. Subtração (-):

   • Uso: Subtrai o segundo operando do primeiro.
   • Sintaxe: operando1 - operando2
   • Exemplo:

     int a = 15;
     int b = 5;
     int diferença = a - b; // diferença é 10

3. Multiplicação (*):

   • Uso: Multiplica dois operandos.
   • Sintaxe: operando1 * operando2
   • Exemplo:

     int a = 4;
     int b = 6;
     int produto = a * b; // produto é 24

4. Divisão (/):

   • Uso: Divide o primeiro operando pelo segundo.
   • Sintaxe: operando1 / operando2
   • Exemplo:

     int a = 20;
     int b = 4;
     int quociente = a / b; // quociente é 5

5. Resto da Divisão (%):

   • Uso: Retorna o restante da divisão do primeiro operando pelo segundo.
   • Sintaxe: operando1 % operando2
   • Exemplo:

     int a = 22;
     int b = 5;
     int resto = a % b; // resto é 2

6. Incremento (++):

   • Uso: Aumenta o valor de um operando em 1.
   • Sintaxe: operando++ ou ++operando
   • Exemplo:

     int a = 5;
     a++; // a é 6

7. Decremento (--):

   • Uso: Diminui o valor de um operando em 1.
   • Sintaxe: operando-- ou --operando
   • Exemplo:

     int a = 5;
     a--; // a é 4

Operadores Lógicos#

Os operadores lógicos são usados para realizar operações lógicas em expressões booleanas. Aqui estão os principais operadores lógicos em C#:

1. E Lógico (&&):

   • Uso: Retorna true se ambos os operandos forem true. Caso contrário, retorna false.
   • Sintaxe: operando1 && operando2
   • Exemplo:

     bool a = true;
     bool b = false;
     bool resultado = a && b; // resultado é false

2. Ou Lógico (||):

   • Uso: Retorna true se pelo menos um dos operandos for true. Caso ambos sejam false, retorna false.
   • Sintaxe: operando1 || operando2
   • Exemplo:

     bool a = true;
     bool b = false;
     bool resultado = a || b; // resultado é true

3. Não Lógico (!):

   • Uso: Inverte o valor do operando. Se o operando for true, retorna false, e vice-versa.
   • Sintaxe: !operando
   • Exemplo:

     bool a = true;
     bool resultado = !a; // resultado é false

4. XOR Lógico (^):

   • Uso: Retorna true se um, e somente um, dos operandos for true. Caso ambos sejam true ou ambos sejam false, retorna false.
   • Sintaxe: operando1 ^ operando2
   • Exemplo:

     bool a = true;
     bool b = false;
     bool resultado = a ^ b; // resultado é true

5. Estruturas de Repetição e Controle de Fluxo em C##

1. Estruturas de Repetição#

As estruturas de repetição (ou loops) são usadas para executar um bloco de código várias vezes. Em C#, você pode usar os seguintes tipos de loops:

1.1. for#

O loop for é usado quando você sabe de antemão quantas vezes precisa repetir um bloco de código.

Sintaxe Básica:

for (inicialização; condição; atualização)
{
    // Bloco de código
}

Exemplo:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"Valor de i: {i}");
}

1.2. while#

O loop while é usado quando a condição de repetição deve ser verificada antes de executar o bloco de código. Ele continua executando enquanto a condição for true.

Sintaxe Básica:

while (condição)
{
    // Bloco de código
}

Exemplo:

int i = 0;
while (i < 5)
{
    Console.WriteLine($"Valor de i: {i}");
    i++;
}

1.3. do-while#

O loop do-while é semelhante ao while, mas garante que o bloco de código seja executado pelo menos uma vez, pois a condição é verificada após a execução.

Sintaxe Básica:

do
{
    // Bloco de código
} while (condição);

Exemplo:

int i = 0;
do
{
    Console.WriteLine($"Valor de i: {i}");
    i++;
} while (i < 5);

2. Comandos de Controle de Fluxo#

2.1. if, else if, else#

Os comandos if, else if e else são usados para tomar decisões baseadas em condições. O bloco de código é executado somente se a condição especificada for true.

Sintaxe Básica:

if (condição1)
{
    // Bloco de código executado se condição1 for verdadeira
}
else if (condição2)
{
    // Bloco de código executado se condição1 for falsa e condição2 for verdadeira
}
else
{
    // Bloco de código executado se todas as condições anteriores forem falsas
}

Exemplo:

int nota = 85;

if (nota >= 90)
{
    Console.WriteLine("Nota A");
}
else if (nota >= 80)
{
    Console.WriteLine("Nota B");
}
else if (nota >= 70)
{
    Console.WriteLine("Nota C");
}
else
{
    Console.WriteLine("Nota D");
}

2.2. switch#

O comando switch é usado para selecionar um bloco de código a ser executado a partir de uma lista de opções baseadas no valor de uma expressão.

Sintaxe Básica:

switch (expressão)
{
    case valor1:
        // Bloco de código executado se expressão == valor1
        break;
    case valor2:
        // Bloco de código executado se expressão == valor2
        break;
    default:
        // Bloco de código executado se nenhum dos casos anteriores for verdadeiro
        break;
}

Exemplo:

int diaDaSemana = 3;

switch (diaDaSemana)
{
    case 1:
        Console.WriteLine("Segunda-feira");
        break;
    case 2:
        Console.WriteLine("Terça-feira");
        break;
    case 3:
        Console.WriteLine("Quarta-feira");
        break;
    case 4:
        Console.WriteLine("Quinta-feira");
        break;
    case 5:
        Console.WriteLine("Sexta-feira");
        break;
    case 6:
        Console.WriteLine("Sábado");
        break;
    case 7:
        Console.WriteLine("Domingo");
        break;
    default:
        Console.WriteLine("Dia inválido");
        break;
}

6. Funções e Classes em C##

Funções em C##

Definição de Função:#

Funções, também conhecidas como métodos, são blocos de código que realizam uma tarefa específica. Elas podem receber parâmetros, executar uma sequência de instruções e, opcionalmente, retornar um valor. Funções ajudam a modularizar o código, tornando-o mais organizado e reutilizável.

Tipos de Funções:#

1. Funções com Retorno:

   • Essas funções retornam um valor de um tipo específico.
   • Sintaxe Básica:

     tipo_de_retorno NomeDaFuncao(parametros)
     {
         // Código da função
         return valor; // (opcional)
     }

   Exemplo:

   public int Somar(int a, int b)
   {
       return a + b;
   }

2. Funções sem Retorno (void):

   • Essas funções não retornam nenhum valor. Elas são usadas para executar ações sem a necessidade de fornecer um resultado.
   • Sintaxe Básica:

     void NomeDaFuncao(parametros)
     {
         // Código da função
     }

   Exemplo:

   public void ImprimirMensagem(string mensagem)
   {
       Console.WriteLine(mensagem);
   }

3. Funções com Parâmetros Opcionais:

   • Parâmetros opcionais permitem que você forneça valores padrão para parâmetros, tornando-os opcionais ao chamar a função.
   • Sintaxe Básica:

     tipo_de_retorno NomeDaFuncao(tipo parametro1 = valor_default, tipo parametro2 = valor_default)
     {
         // Código da função
     }

   Exemplo:

   public void Saudar(string nome = "Visitante")
   {
       Console.WriteLine($"Olá, {nome}!");
   }

4. Funções de Sobrecarga:

   • Sobrecarga de funções permite definir várias funções com o mesmo nome, mas com diferentes tipos ou números de parâmetros.
   • Sintaxe Básica:

     tipo_de_retorno NomeDaFuncao(tipo parametro1)
     {
         // Código da função
     }
     
     tipo_de_retorno NomeDaFuncao(tipo parametro1, tipo parametro2)
     {
         // Código da função
     }

   Exemplo:

   public int Multiplicar(int a, int b)
   {
       return a * b;
   }
   
   public double Multiplicar(double a, double b)
   {
       return a * b;
   }

Visibilidade de Funções:#

A visibilidade de uma função determina onde ela pode ser acessada dentro do código. Em C#, a visibilidade é controlada por modificadores de acesso.

1. public:

   • A função pode ser acessada de qualquer lugar no código, tanto dentro quanto fora da classe onde está definida.

   Exemplo:

   public void MostrarInformacao()
   {
       // Código da função
   }

2. private:

   • A função só pode ser acessada dentro da própria classe onde está definida. Não pode ser chamada de fora dessa classe.

   Exemplo:

   private void CalcularValor()
   {
       // Código da função
   }

3. protected:

   • A função pode ser acessada dentro da própria classe e por classes que herdam dessa classe.

   Exemplo:

   protected void AtualizarDados()
   {
       // Código da função
   }

4. internal:

   • A função pode ser acessada dentro do mesmo assembly (ou projeto). Não é visível fora do assembly, mesmo que esteja em uma classe pública.

   Exemplo:

   internal void ProcessarDados()
   {
       // Código da função
   }

5. protected internal:

   • A função pode ser acessada dentro do mesmo assembly e por classes que herdam da classe em qualquer assembly.

   Exemplo:

   protected internal void VerificarStatus()
   {
       // Código da função
   }

Exemplo Completo:#

Aqui está um exemplo que mostra diferentes tipos de funções e visibilidade em uma classe:

using System;

class Calculadora
{
    // Função com retorno
    public int Somar(int a, int b)
    {
        return a + b;
    }

    // Função sem retorno
    public void ExibirResultado(int resultado)
    {
        Console.WriteLine($"O resultado é: {resultado}");
    }

    // Função com parâmetros opcionais
    public void Saudar(string nome = "Visitante")
    {
        Console.WriteLine($"Olá, {nome}!");
    }

    // Função de sobrecarga
    public double Multiplicar(double a, double b)
    {
        return a * b;
    }

    // Função privada
    private void MostrarMensagem()
    {
        Console.WriteLine("Mensagem privada");
    }

    // Função protegida
    protected void MostrarDetalhes()
    {
        Console.WriteLine("Detalhes protegidos");
    }
}

class Program
{
    static void Main()
    {
        Calculadora calc = new Calculadora();
        
        // Chamada de função pública com retorno
        int resultado = calc.Somar(5, 10);
        calc.ExibirResultado(resultado);

        // Chamada de função com parâmetro opcional
        calc.Saudar();

        // Chamada de função de sobrecarga
        double produto = calc.Multiplicar(2.5, 4.0);
        Console.WriteLine($"O produto é: {produto}");
        
        // As seguintes chamadas não são possíveis porque as funções são privadas ou protegidas:
        // calc.MostrarMensagem(); // Erro: 'MostrarMensagem' é privado
        // calc.MostrarDetalhes(); // Erro: 'MostrarDetalhes' é protegido
    }
}

Classes e Objectos#

Definição de Classe:#

Uma classe é um molde ou um modelo para criar objetos. Ela define um tipo de dado que encapsula dados e métodos que operam sobre esses dados. Em programação orientada a objetos, a classe é uma das principais construções que permitem organizar e manipular dados e comportamentos de forma modular e reutilizável.

Componentes de uma Classe:

1. Campos: Variáveis que armazenam dados.
2. Propriedades: Métodos especiais que fornecem acesso aos campos da classe.
3. Métodos: Funções que definem comportamentos ou ações da classe.
4. Construtores: Métodos especiais chamados quando um objeto é instanciado, usados para inicializar o objeto.

Definição de Objeto:#

Um objeto é uma instância de uma classe. Ele representa uma entidade específica com seus próprios valores de dados e comportamentos definidos pela classe. Cada objeto pode ter estados diferentes, mas compartilha a mesma estrutura e comportamento definidos pela classe.

Sintaxe Básica para Definição de uma Classe:#

Estrutura Geral:

class NomeDaClasse
{
    // Campos
    tipo nomeDoCampo;

    // Propriedades
    public tipo NomePropriedade { get; set; }

    // Construtores
    public NomeDaClasse()
    {
        // Inicialização padrão
    }

    // Métodos
    public void NomeDoMetodo()
    {
        // Código do método
    }
}

Exemplo Detalhado:#

Vamos criar uma classe Pessoa que exemplifica os conceitos básicos de classes e objetos.

Classe Pessoa:

using System;

class Pessoa
{
    // Campos
    private string nome;
    private int idade;

    // Propriedades
    public string Nome
    {
        get { return nome; }
        set { nome = value; }
    }

    public int Idade
    {
        get { return idade; }
        set
        {
            if (value >= 0) // Validação
                idade = value;
            else
                Console.WriteLine("Idade não pode ser negativa.");
        }
    }

    // Construtor
    public Pessoa(string nome, int idade)
    {
        this.nome = nome;
        this.idade = idade;
    }

    // Método
    public void Apresentar()
    {
        Console.WriteLine($"Olá, meu nome é {nome} e tenho {idade} anos.");
    }
}

class Program
{
    static void Main()
    {
        // Criar um objeto da classe Pessoa
        Pessoa pessoa1 = new Pessoa("Ana", 30);
        
        // Usar o método do objeto
        pessoa1.Apresentar();

        // Acessar e modificar propriedades
        pessoa1.Nome = "Maria";
        pessoa1.Idade = 25;
        pessoa1.Apresentar();
    }
}

Explicação do Exemplo:#

1. Campos:

   • private string nome; e private int idade;: Campos privados que armazenam o nome e a idade da pessoa. São acessíveis apenas dentro da classe Pessoa.

2. Propriedades:

   • public string Nome { get; set; }: Propriedade que fornece acesso ao campo nome. O getter (get) retorna o valor do campo, e o setter (set) define o valor do campo.
   • public int Idade { get; set; }: Propriedade que fornece acesso ao campo idade com validação no setter para garantir que a idade não seja negativa.

3. Construtor:

   • public Pessoa(string nome, int idade): Construtor que inicializa os campos nome e idade com valores fornecidos ao criar uma nova instância de Pessoa.

4. Método:

   • public void Apresentar(): Método que exibe uma mensagem com o nome e a idade da pessoa. É uma ação que o objeto Pessoa pode realizar.

5. Instanciação e Uso de Objetos:

   • Pessoa pessoa1 = new Pessoa("Ana", 30);: Cria um novo objeto Pessoa com nome “Ana” e idade 30.
   • pessoa1.Apresentar();: Chama o método Apresentar do objeto pessoa1 para exibir suas informações.

Resumo e Conclusão da Aula#

Nesta aula, exploramos os fundamentos da programação em C#, incluindo variáveis, estruturas de controle, repetição, funções e classes. Esses conceitos são essenciais para o desenvolvimento de qualquer aplicação em C#. Certifique-se de praticar esses conceitos para solidificar sua compreensão.

Projecto Final:#

Criação de um programa que permita ao usuário adicionar novos produtos com nome, preço e quantidade. O programa deve permitir listar todos os produtos cadastrados e encerrar o programa.

Programa de Cadastro de Produtos#

using System;
using System.Collections.Generic;

class Produto
{
    public string Nome { get; set; }
    public decimal Preco { get; set; }
    public int Quantidade { get; set; }

    public override string ToString()
    {
        return $"Nome: {Nome}, Preço: {Preco:C}, Quantidade: {Quantidade}";
    }
}

class Program
{
    static void Main()
    {
        List<Produto> produtos = new List<Produto>();
        bool continuar = true;

        while (continuar)
        {
            Console.WriteLine("Escolha uma opção:");
            Console.WriteLine("1. Adicionar produto");
            Console.WriteLine("2. Listar produtos");
            Console.WriteLine("3. Encerrar");
            Console.Write("Opção: ");
            string opcao = Console.ReadLine();

            switch (opcao)
            {
                case "1":
                    AdicionarProduto(produtos);
                    break;
                case "2":
                    ListarProdutos(produtos);
                    break;
                case "3":
                    continuar = false;
                    break;
                default:
                    Console.WriteLine("Opção inválida. Tente novamente.");
                    break;
            }
        }

        Console.WriteLine("Programa encerrado.");
    }

    static void AdicionarProduto(List<Produto> produtos)
    {
        Console.Write("Digite o nome do produto: ");
        string nome = Console.ReadLine();

        Console.Write("Digite o preço do produto: ");
        decimal preco;
        while (!decimal.TryParse(Console.ReadLine(), out preco) || preco < 0)
        {
            Console.Write("Preço inválido. Digite novamente: ");
        }

        Console.Write("Digite a quantidade do produto: ");
        int quantidade;
        while (!int.TryParse(Console.ReadLine(), out quantidade) || quantidade < 0)
        {
            Console.Write("Quantidade inválida. Digite novamente: ");
        }

        Produto produto = new Produto
        {
            Nome = nome,
            Preco = preco,
            Quantidade = quantidade
        };

        produtos.Add(produto);
        Console.WriteLine("Produto adicionado com sucesso!");
    }

    static void ListarProdutos(List<Produto> produtos)
    {
        if (produtos.Count == 0)
        {
            Console.WriteLine("Nenhum produto cadastrado.");
            return;
        }

        Console.WriteLine("Lista de produtos cadastrados:");
        foreach (var produto in produtos)
        {
            Console.WriteLine(produto);
        }
    }
}

Explicação do Código:#

1. Classe Produto:

   • Propriedades:
     • Nome: Nome do produto.
     • Preco: Preço do produto.
     • Quantidade: Quantidade disponível.
   • Método ToString(): Sobrescrito para formatar a saída quando o objeto Produto é exibido.

2. Classe Program:

   • Método Main():
     • Usa um loop while para exibir um menu e processar a escolha do usuário.
     • Dependendo da escolha (1, 2, ou 3), chama métodos para adicionar produtos, listar produtos ou encerrar o programa.
   • Método AdicionarProduto():
     • Solicita ao usuário as informações do produto, valida o preço e a quantidade, cria um novo Produto e o adiciona à lista.
   • Método ListarProdutos():
     • Exibe todos os produtos cadastrados ou uma mensagem se a lista estiver vazia.