Bridge Pattern – separarea abstractizării de implementare - Blog

Bridge Pattern – separarea abstractizării de implementare

Doru Bulubasa
19 November 2025

Î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:

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: