The Bridge Pattern
The bridge pattern decouples an abstraction from its implementation so the
two can vary independently. In other words we make a bridge between
the abstraction and its implementation and therefore we won't have a
binding between the two. The pattern helps us whenever we need to
select or switch the implementation at runtime.
For a UML diagram of the pattern go to dofactory site.
Example in C#
How does it work? Lets look at a small example.
#region The Abstraction
public class Abstraction
{
#region Members
private Bridge _bridge;
#endregion
#region Ctor
/// <summary>
/// Construct a new Abstraction object with
/// the given bridge
/// </summary>
/// <param name="bridge">The given bridge</param>
public Abstraction(Bridge bridge)
{
_bridge = bridge;
}
#endregion
#region Methods
/// <summary>
/// The method demonstrate the call for
/// the bridge object by its abstraction
/// </summary>
public void Operation()
{
Console.Write("Using");
_bridge.OperationImplementation();
}
#endregion
}
#endregion
#region The Bridge And Its Implementations
public interface Bridge
{
void OperationImplementation();
}
public class BridgeImplementationA : Bridge
{
#region Bridge Members
/// <summary>
/// Perform implementation A operation
/// </summary>
public void OperationImplementation()
{
Console.Write("BridgeImplementationA");
}
#endregion
}
public class BridgeImplementationB : Bridge
{
#region Bridge Members
/// <summary>
/// Perform implementation B operation
/// </summary>
public void OperationImplementation()
{
Console.Write("BridgeImplementationB");
}
#endregion
}
#endregion
You can see that the abstraction holds a bridge object and gets the bridge in the
constructor. Therefore, whenever one of the implementation is needed you pass it
in the constructor and you won't be coupled to the implementation.
Summary
To sum up, use the bridge pattern whenever you identify that the operations
you write not always need to be implemented in the same way.
Another reason is not to bind the abstraction to its implementation.
