Bridge Pattern

Bridge pattern (most) - strukturalny wzorzec projektowy pozwalający oddzielić abstrakcję obiektu od jego implementacji.

Zobaczmy na diagram klas:

Klasy które uczestniczą w tym wzorcu:
Abstraction - definiuje interfejs abstrackji oraz posiada referencję do implementacji
RefinedAbstraction - rozszerza interfejs abstrakcji
Implementator - definiuje interfejs implementatora. Interfejs ten nie musi być zgodny z abstrakcją. Przeważnie Implementator dostarcza niskopoziomowego interfejsu, a abstrakcja operuje na tym interfejsie.
ConcreteImplementator - implementuje interfejs Implementatora.

Dzięki wzorcowi oddzielamy interfejs od implementacji. Głównym celem jest wydzielenie operacji do interfejsu aby klient i serwis mogli działać oddzielnie.
Zysk z zastosowania wzorca:

• oddzielenie interfejsu od implementacji
• zwiększona elastyczność - zarówno interfejs jak i konkretną klasę można rozwijać indywidualnie
• ukrycie implementacji przed klientem 

Przykład realizacji:

Code:

using System;
using System.Collections.Generic;
using System.Linq;

namespace BridgePatternExample
{
    public class Program
    {
        static void Main()
        {
            var customers = new Customers{DataContext = new CustomerContext()};
            customers.Add(new Customer{BirthYear = 2000, FirstName = "Mark", Id = 1, LastName = "Poldkowski"});
            customers.Add(new Customer { BirthYear = 2000, FirstName = "Sylwester", Id = 2, LastName = "Markowski" });
            customers.Add(new Customer { BirthYear = 2000, FirstName = "Paweł", Id = 3, LastName = "Szymanowski" });

            customers.Print();
        }
    }

    public abstract class CustomersTable
    {
        public DataContext DataContext { get; set; }

        public abstract void Add(EntityBase  customer);
        public abstract void Remove(EntityBase customer);
        public abstract EntityBase Find(int id);
        public abstract void Print();
    }

    public class Customers : CustomersTable
    {
        public override void Add(EntityBase customer)
        {
            DataContext.AddEntity(customer);
        }

        public override void Remove(EntityBase customer)
        {
            DataContext.RemoveEntity(customer);
        }

        public override EntityBase Find(int id)
        {
            return DataContext.FindEntity(id);
        }

        public override void Print()
        {
            DataContext.PrintCustomers();
        }
    }

    public abstract class DataContext
    {
        public abstract void AddEntity(EntityBase entity);
        public abstract void RemoveEntity(EntityBase entity);
        public abstract EntityBase FindEntity(int id);

        public abstract void PrintCustomers();
    }

    public class CustomerContext : DataContext
    {
        private List<EntityBase> _customers = new List<EntityBase>();

        public override void AddEntity(EntityBase entity)
        {
            _customers.Add(entity);
        }

        public override void RemoveEntity(EntityBase entity)
        {
            _customers.Remove(entity);
        }

        public override EntityBase FindEntity(int id)
        {
            return _customers.FirstOrDefault(entity => entity.Id == id);
        }

        public override void PrintCustomers()
        {
            foreach (var customer in _customers)
            {
                Console.WriteLine(customer);
            }
        }
    }

    public abstract class EntityBase
    {
        public int Id { get; set; }
    }

    public class Customer : EntityBase
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public int BirthYear { get; set; }

        public override string ToString()
        {
            return string.Format("{0} {1} {2}", FirstName, LastName, BirthYear);
        }
    }
}