"Orientação a Objetos e Clean Code em Projetos .NET: Como Escrever Código Simples e Fácil de Manter"

🧹 Orientação a Objetos e Clean Code em Projetos .NET

🔹 Introdução

No desenvolvimento de software, especialmente no back-end com .NET, é comum encontrarmos projetos que crescem rápido e se tornam difíceis de manter. Isso geralmente acontece por falta de organização no código.

Dois pilares ajudam a evitar esse problema: Programação Orientada a Objetos (POO) e Clean Code.

Enquanto a POO fornece uma forma de estruturar o sistema em classes e objetos, o Clean Code traz princípios que deixam o código legível, simples e de fácil manutenção.

Neste artigo, vamos ver como aplicar esses conceitos juntos em um pequeno exemplo prático com C#.

🔹 Revisão Rápida de POO

A Programação Orientada a Objetos se baseia em quatro pilares principais:

1. Encapsulamento → proteger os dados de acesso direto, expondo apenas o necessário.
2. Herança → reaproveitar código criando hierarquias de classes.
3. Polimorfismo → permitir que métodos tenham comportamentos diferentes dependendo do contexto.
4. Abstração → focar no que importa, escondendo detalhes de implementação.

Esses conceitos ajudam a criar sistemas mais organizados e reutilizáveis.

🔹 O que é Clean Code?

O conceito de Clean Code foi popularizado por Robert C. Martin (“Uncle Bob”).

O objetivo é simples: escrever código que seja fácil de ler e manter.

Alguns princípios importantes:

• Nomes claros para classes, métodos e variáveis.
• Métodos curtos que fazem apenas uma coisa.
• Evitar duplicação de código.
• Organização em camadas ou responsabilidades.

🔹 Exemplo Prático em .NET (C#)

Imagine que precisamos criar um sistema de cadastro de produtos.

Primeiro, um exemplo de código sem POO e sem Clean Code:

using System;
using System.Collections.Generic;

class Program
{
  static void Main()
  {
      List<string> produtos = new List<string>();
      produtos.Add("Mouse,50");
      produtos.Add("Teclado,100");

      foreach (var p in produtos)
      {
          var dados = p.Split(",");
          Console.WriteLine($"Produto: {dados[0]}, Preço: {dados[1]}");
      }
  }
}

Esse código funciona, mas tem problemas:

• Produto representado como string (frágil e difícil de manter).
• Preço armazenado sem tipo adequado.
• Nenhum encapsulamento ou clareza.

✅ Refatorando com POO e Clean Code

Agora vamos aplicar os conceitos:

using System;
using System.Collections.Generic;

// Classe Produto aplica encapsulamento
public class Produto
{
  public string Nome { get; private set; }
  public decimal Preco { get; private set; }

  public Produto(string nome, decimal preco)
  {
      Nome = nome;
      Preco = preco;
  }

  public void ExibirInfo()
  {
      Console.WriteLine($"Produto: {Nome}, Preço: {Preco:C}");
  }
}

// Classe responsável pela lógica de cadastro
public class CadastroProduto
{
  private readonly List<Produto> _produtos = new();

  public void AdicionarProduto(Produto produto)
  {
      _produtos.Add(produto);
  }

  public void ListarProdutos()
  {
      foreach (var produto in _produtos)
      {
          produto.ExibirInfo();
      }
  }
}

// Programa principal
class Program
{
  static void Main()
  {
      var cadastro = new CadastroProduto();
      cadastro.AdicionarProduto(new Produto("Mouse", 50m));
      cadastro.AdicionarProduto(new Produto("Teclado", 100m));

      cadastro.ListarProdutos();
  }
}

🔍 O que melhorou?

• Encapsulamento: Produto agora tem propriedades seguras (Nome e Preco).
• Clean Code: nomes claros (AdicionarProduto, ListarProdutos).
• Separação de responsabilidades:
• Produto representa os dados.
• CadastroProduto cuida da lógica de cadastro.
• Program apenas executa.

Resultado: um código mais legível, reutilizável e fácil de dar manutenção.

🔹 Conclusão

A combinação de POO e Clean Code em projetos .NET não é apenas uma boa prática, é um diferencial profissional.

Quando escrevemos código limpo e orientado a objetos, estamos pensando não só em nós mesmos, mas também em quem vai ler e dar manutenção no sistema no futuro.

O exemplo que vimos é simples, mas reflete situações do dia a dia no back-end: sistemas de cadastro, APIs e serviços que precisam ser claros e organizados.

👉 Próximos passos:

• Explorar interfaces e injeção de dependência no .NET.
• Estudar princípios SOLID para elevar ainda mais a qualidade do código.
• Praticar Clean Code em projetos reais, refatorando códigos existentes.

"Aprender a programar é fácil, o desafio é escrever código que você e outros desenvolvedores terão prazer em manter amanhã."