Ludo Programming

În arhitectura software, pe măsură ce proiectele cresc, apare des nevoia de a combina mai multe tipuri de abstractizări cu mai multe tipuri de implementări. Dacă nu ești atent, ajungi foarte rapid la explozia de clase – zeci de combinații posibile între funcționalități, fiecare cerând propria clasă derivată.

Aici intră în scenă Bridge Pattern, un pattern structural care separă clar abstractizarea de implementare, permițându-le să evolueze independent.

🧩 Ce este Bridge Pattern?

Bridge Pattern ne oferă un mod de a conecta două ierarhii de clase diferite:

• una pentru abstractizare (de obicei logica de nivel înalt)

• una pentru implementare (detalii concrete)

În loc să ai o singură ierarhie mare, le separi, iar comunicarea între ele se face printr-o punte (bridge), reprezentată de o interfață sau o clasă abstractă.

Astfel ai:

Abstraction ---> Implementation

🧠 De ce e util Bridge Pattern?

• ✔ Evită explozia de subclase

• ✔ Permite adăugarea de noi implementări fără a modifica abstractizarea

• ✔ Oferă flexibilitate în configurare și extindere

• ✔ Este excelent când lucrezi cu mai multe platforme, drivere, servicii sau dispozitive

📦 Exemplu practic (C# / .NET)

Să spunem că avem un sistem care trimite notificări. Notificările pot fi:

• Email

• SMS

Iar nivelurile notificărilor pot fi:

• Simple

• Importante

Fără Bridge Pattern, am avea clase de genul:

• SimpleEmailNotification

• ImportantEmailNotification

• SimpleSmsNotification

• ImportantSmsNotification

  …și devine greu de scalat.

Cu Bridge Pattern: separăm ce trimitem de cum trimitem.

Implementarea (puntea):

public interface INotificationSender
{
    void Send(string message);
}

public class EmailSender : INotificationSender
{
    public void Send(string message)
    {
        Console.WriteLine($"Email sent: {message}");
    }
}

public class SmsSender : INotificationSender
{
    public void Send(string message)
    {
        Console.WriteLine($"SMS sent: {message}");
    }
}

Abstractizarea (nivelul logicii):

public abstract class Notification
{
    protected readonly INotificationSender _sender;

    protected Notification(INotificationSender sender)
    {
        _sender = sender;
    }

    public abstract void Notify(string message);
}

Versiuni ale abstractizării:

public class SimpleNotification : Notification
{
    public SimpleNotification(INotificationSender sender) : base(sender) { }

    public override void Notify(string message)
    {
        _sender.Send("[Simple] " + message);
    }
}

public class ImportantNotification : Notification
{
    public ImportantNotification(INotificationSender sender) : base(sender) { }

    public override void Notify(string message)
    {
        _sender.Send("[IMPORTANT] " + message);
    }
}

Utilizare:

var emailSender = new EmailSender();
var smsSender = new SmsSender();

Notification n1 = new SimpleNotification(emailSender);
n1.Notify("Salut!");

Notification n2 = new ImportantNotification(smsSender);
n2.Notify("Ai un mesaj important!");

🏁 Concluzie

Bridge Pattern este excelent pentru situațiile în care ai nevoie de flexibilitate între ceva abstract și modul în care este implementat. În loc să creezi o singură ierarhie mare de clase, le separi în două ierarhii independente, unite printr-o interfață (bridge).

Este ideal pentru:

• sisteme cross-platform

• module pluggable

• scenarii de extensibilitate ridicată

• arhitecturi enterprise complexe