.jpg)
Seja muito bem-vindo à Academy Code Christ!
⚙️ TRILHA C Sharp Etapa 06
Programação Modular e Organização
%20-%20Copia.png)
.png)
💻 Pratique o que você aprende
.png)
Você já deve ter percebido que conforme o código cresce, fica difícil localizar e alterar partes específicas.
Imagine um arquivo de 5000 linhas de código, com dezenas de funções, variáveis e regras misturadas — seria um pesadelo entender ou corrigir algo!
A programação modular resolve isso.
Ela é a arte de dividir o programa em
partes menores, chamadas módulos, que interagem entre si de maneira
organizada e previsível.
Em C#, essa modularização é feita principalmente através de métodos, classes, namespaces e arquivos separados.
O Que é Programação Modular?
Programação modular significa dividir um sistema grande em blocos menores, independentes e reutilizáveis.
🎯 Objetivos da modularização:
● Tornar o código mais fácil de entender.
● Facilitar testes e manutenção.
● Permitir que várias pessoas trabalhem em partes diferentes do sistema.
● Evitar repetição de código.
● Possibilitar a reutilização de partes em novos projetos.
📘 Em resumo: cada módulo deve fazer uma só coisa e fazê-la bem.
Estruturando Programas em Arquivos Separados
Em programas simples, colocar tudo no Program.cs é suficiente.
Mas à medida que o projeto cresce, é
melhor separar o código em vários arquivos, cada um com uma responsabilidade
específica.
Por exemplo:
/ProjetoEscola
├── Program.cs
├── Aluno.cs
├── Professor.cs
└── Utilidades.cs
Cada arquivo conterá uma classe com suas próprias funções (métodos).
👩🎓 Exemplo do arquivo Aluno.cs
namespace ProjetoEscola
{
class Aluno
{
public string Nome { get; set; }
public double Nota1 { get; set; }
public double Nota2 { get; set; }
public double Nota3 { get; set; }
public double CalcularMedia()
{
return (Nota1 + Nota2 + Nota3) / 3;
}
public void ExibirInformacoes()
{
Console.WriteLine($"Aluno: {Nome} | Média: {CalcularMedia():F2}");
}
}
}
📘 Arquivo Program.cs
using ProjetoEscola;
class Program
{
static void Main()
{
Aluno aluno1 = new Aluno();
aluno1.Nome = "Lucas";
aluno1.Nota1 = 8.0;
aluno1.Nota2 = 7.5;
aluno1.Nota3 = 9.0;
aluno1.ExibirInformacoes();
}
}
🧠 Perceba:
● Cada componente está em seu arquivo.
● O Program.cs apenas coordena as ações.
● O código da classe Aluno fica isolado e reutilizável.
Entendendo os Namespaces
Um namespace é como uma “pasta” para suas classes.
Serve para organizar o código e
evitar conflitos de nomes entre partes diferentes do programa.
Por exemplo:
namespace ProjetoEscola
{
class Aluno
{
// código da classe
}
}
Quando você quer usar essa classe em outro arquivo, basta importar o namespace no topo:
using ProjetoEscola;
Assim você pode acessar Aluno diretamente.
💡 Dica profissional: use namespaces para organizar diferentes partes do sistema, como ProjetoEscola.Modelos, ProjetoEscola.Servicos, ProjetoEscola.Utilitarios.
Reutilizando Módulos em Outros Projetos
Uma grande vantagem da modularização é reutilizar código.
Se a classe Aluno for bem escrita, você poderá copiá-la e usá-la em
outro sistema sem modificar nada.
Por exemplo, o cálculo de média poderia virar uma biblioteca:
namespace BibliotecaEscola
{
public static class Calculos
{
public static double Media(double[] notas)
{
double soma = 0;
foreach (var nota in notas)
soma += nota;
return soma / notas.Length;
}
}
}
E no programa principal:
using BibliotecaEscola;
class Program
{
static void Main()
{
double[] notas = {7.5, 8.0, 9.0};
double media = Calculos.Media(notas);
Console.WriteLine("Média: " + media);
}
}
⚡ Uma biblioteca como essa poderia ser exportada para outros projetos e usada como um módulo genérico.
Responsabilidade Única
Um dos princípios mais importantes da modularização é o Princípio da Responsabilidade Única (Single Responsibility Principle - SRP).
Cada módulo deve ter uma responsabilidade bem definida.
💡 Exemplo:
● Um módulo deve cuidar do cálculo.
● Outro deve exibir resultados.
● Outro deve ler dados do usuário.
Quando misturamos tudo em um único lugar, o código se torna difícil de manter e propenso a erros.
Separando Funções em Classes Específicas
Um sistema pode crescer com classes que representam cada “peça” do processo.
Por exemplo, num sistema de notas escolares, poderíamos ter:
● Aluno.cs → guarda informações e calcula média.
● Professor.cs → lida com conteúdo das matérias.
● Turma.cs → agrupa alunos e gerencia listas.
● ServicoDeRelatorio.cs → gera relatórios.
Cada classe tem seus próprios métodos e atribuições.
Assim, o sistema fica mais fácil de
evoluir.
Comunicação entre Módulos
Os módulos se comunicam principalmente através de métodos públicos e parâmetros.
Por exemplo:
class Turma
{
public string Nome { get; set; }
public List<Aluno> Alunos { get; set; } = new List<Aluno>();
public void AdicionarAluno(Aluno aluno)
{
Alunos.Add(aluno);
}
public void ExibirTurma()
{
Console.WriteLine("Turma: " + Nome);
foreach (var aluno in Alunos)
aluno.ExibirInformacoes();
}
}
E no Program.cs:
Turma turmaA = new Turma();
turmaA.Nome = "1º Ano A";
Aluno ana = new Aluno { Nome = "Ana", Nota1 = 9, Nota2 = 8, Nota3 = 7 };
Aluno pedro = new Aluno { Nome = "Pedro", Nota1 = 6, Nota2 = 5, Nota3 = 7 };
turmaA.AdicionarAluno(ana);
turmaA.AdicionarAluno(pedro);
turmaA.ExibirTurma();
📘 Um módulo chama o outro de forma controlada e organizada, sem interferir na lógica interna dele.
Modularização e Testes
Quando o código é modular, você consegue testar partes específicas, sem precisar rodar o sistema inteiro.
Por exemplo, você pode testar apenas o método de média do aluno:
double resultado = aluno1.CalcularMedia();
Isso permite verificar isoladamente se a função está funcionando corretamente — um conceito fundamental chamado teste unitário.
Estruturando Pastas e Classes (Padrão Profissional)
📁 Estrutura organizada de um projeto real pode ser assim:
/ProjetoLoja
├── /Modelos
│ ├── Produto.cs
│ ├── Cliente.cs
│ └── Pedido.cs
├── /Servicos
│ ├── ServicoDeVenda.cs
│ └── ServicoDeEntrega.cs
├── /Utilitarios
│ └── Validacoes.cs
└── Program.cs
Cada pasta representa uma camada de responsabilidade
diferente.
Quando o sistema crescer, essa
organização evitará caos.
Exemplo Prático: Sistema Modular Simples
Vamos criar um pequeno sistema modular de produtos:
Produto.cs
namespace Loja
{
public class Produto
{
public string Nome { get; set; }
public double Preco { get; set; }
public void ExibirInfo()
{
Console.WriteLine($"Produto: {Nome} | Preço: R${Preco:F2}");
}
}
}
Carrinho.cs
using System.Collections.Generic;
namespace Loja
{
public class Carrinho
{
public List<Produto> Itens { get; set; } = new List<Produto>();
public void AdicionarProduto(Produto p)
{
Itens.Add(p);
}
public double CalcularTotal()
{
double total = 0;
foreach (var item in Itens)
total += item.Preco;
return total;
}
public void ListarItens()
{
foreach (var item in Itens)
item.ExibirInfo();
Console.WriteLine($"Total: R${CalcularTotal():F2}");
}
}
}
Program.cs
using Loja;
class Program
{
static void Main()
{
Produto p1 = new Produto { Nome = "Teclado", Preco = 100 };
Produto p2 = new Produto { Nome = "Mouse", Preco = 60 };
Carrinho carrinho = new Carrinho();
carrinho.AdicionarProduto(p1);
carrinho.AdicionarProduto(p2);
Console.WriteLine("Itens no carrinho:");
carrinho.ListarItens();
}
}
🎯 Resultado:
Itens no carrinho:
Produto: Teclado | Preço: R$100,00
Produto: Mouse | Preço: R$60,00
Total: R$160,00
Benefícios da Programação Modular
✅
Código mais limpo e organizado.
✅ Facilidade na manutenção — mudar uma
parte não quebra o resto.
✅ Possibilidade de reaproveitamento.
✅ Permite que várias pessoas trabalhem
no mesmo projeto.
✅ Facilita testes e futuras melhorias.
Conclusão
Você acabou de dar mais um passo crucial.
A partir deste ponto, você não é apenas
alguém que escreve código — você projeta sistemas. 💎
Agora você sabe:
● Dividir o código em módulos independentes;
● Criar e importar namespaces;
● Organizar classes e arquivos de forma profissional;
● Fazer com que módulos trabalhem juntos sem se misturarem.
Essa estrutura é a base da Programação Orientada a Objetos (POO), que será o próximo grande tema da etapa..png)
.png)
Postar um comentário