C# -  Acoplamento Forte x Acoplamento Fraco

 Hoje vamos recordar um dos fundamentos que torna uma código robusto. Vamos recordar e comparar um código com acoplamento forte com acoplamento fraco.

O acoplamento é a medida de quão interconectadas estão as classes e os subsistemas de um projeto de software.

Assim, o acoplamento é o nível de dependência/conhecimento que pode existir entre os módulos/classes do sistema e existem dois tipos de acoplamento:

1 - Acoplamento forte
2 - Acoplamento fraco

Podemos dizer que:

Usar código fracamente acoplado possui as seguintes vantagens

- Um módulo não quebra outros módulos;
- Melhora a testabilidade;
- O código é mais fácil de manter;
- Fica menos afetado por alterações em outros componentes;

Um código fortemente acoplado indica que as classes e os objetos são dependentes um do outro e, portanto, reduzem a reutilização do código.

Assim o acoplamento fraco é preferido, uma vez que alterar uma classe não afetará outra. Ele Reduz dependências em uma classe e isso significa que essa abrodagem facilita a reutilização de código.

Selecionando os principais tipos de relacionamento entre classes que são usados no dia a dia podemos destacar a herança, a composição e o agregação.

Onde a herança nos leva a um acoplamento mais forte quea composição e a agregação.

A seguir vamos mostrar um código com forte acoplamento:

namespace Acoplamento;
public class CarrinhoCompra
{
    public float Preco;
    public int Quantidade;
}

public class CarrinhoItens
{
    public CarrinhoCompra[] items;
}
public class Pedido
{
    private CarrinhoItens carrinho;
    private float imposto;
    public Pedido(CarrinhoItens carrinho, float imposto)
    {
        this.carrinho = carrinho;
        this.imposto = imposto;
    }
    public float PedidoTotal()
    {
        float carrinhoTotal = 0;
        for (int i = 0; i < carrinho.items.Length; i++)
        {
            carrinhoTotal += carrinho.items[i].Preco * 
                                             carrinho.items[i].Quantidade;
        }
        carrinhoTotal += carrinhoTotal * imposto;
        return carrinhoTotal;
    }
}

Este código foi simplificado para facilitar o entendimento e a leitura. Assim o código das classes CarrinhoCompra, CarrinhoItens e Pedido foi definido em um único arquivo.

Neste código temos um forte acoplamento que vair criar algumas dificuldades.

O método PedidoTotal() fornece o valor completo para os itens atuais dos carrinhos.

Se quisermos adicionar uma política de desconto neste código isso será muito difícil de implementar  porque temos que fazer alterações em todas as classes, pois o código esta muito acoplado.

A seguir vamos ajustar o código para ter um acoplamento mais fraco.

public class CarrinhoCompra
{
    public float Preco;
    public int Quantidade;
    public float GetTotalItem()
    {
        return Preco * Quantidade;
    }
}

public class CarrinhoItens
{
    public CarrinhoCompra[] items;
    public float GetCarrinhoItensTotal()
    {
        float carrinhoTotal = 0;
        foreach (CarrinhoCompra item in items)
        {
            carrinhoTotal += item.GetTotalItem();
        }
        return carrinhoTotal;
    }
}
public class Pedido
{
    private CarrinhoItens carrinho;
    private float imposto;
    public Pedido(CarrinhoItens carrinho, float imposto)
    {
        this.carrinho = carrinho;
        this.imposto = imposto;
    }
    public float PedidoTotal()
    {
        return carrinho.GetCarrinhoItensTotal() * (2.0f + imposto);
    }
}

Agora se quisermos adicionar uma política de desconto, é muito fácil alterar o código para conseguir isso pois refatoramos o código para ter um acoplamento mais fraco.

Abaixo um exemplo de implementação possível alterando apenas a classe CarrinhoCompra:

public class CarrinhoCompra
{
    public float Preco;
    public int Quantidade;}

    public float Desconto

    public float GetTotalItem()
    {
        return Preco * Quantidade - Desconto;
    }
}

Assim neste exemplo bem simples vemos como o acoplamento fraco pode nos ajudar e tivemos que alterar apenas uma classe do projeto.

Em um projeto maior se o código estiver fortemente acoplado qualquer alteração pode se propagar pelo sistema inteiro dificultando a manutenção e os testes.

E estamos conversados...

"Também não oprimirás o estrangeiro; pois vós conheceis o coração do estrangeiro, pois fostes estrangeiros na terra do Egito."
Êxodo 23:9

Referências:

José Carlos Macoratti