Structural Patterns

Bridge Pattern

Bridge Pattern is commonly known as Handle/Body idiom in C++ community. This pattern is used for decoupling an abstraction from its implementation so that the two can vary independently. 

The Gang Of Four (GoF) defined the Bridge pattern as follows in their most famous book "Design Patterns" Gamma et al., Addison-Wesley, ISBN:0-201-63361-2" - "Decouple an abstraction from its implementation so that the two can vary independently." 

Non-software Example 

A household switch controlling lights, ceiling fans, etc. is an example of the Bridge. The purpose of the switch is to turn a device on or off. The actual switch can be implemented as a pull chain, simple two-position switch, or a variety of dimmer switches. [Michael Duell, "Non-software examples of software design patterns", Object Magazine, Jul 97, p54] 

The structure of a Bridge Pattern is shown below.  



The Abstraction defines the interface that the client uses for interaction with this abstraction. That is, the client makes requests directly to the Abstraction object, as that is the only interface known to the client. The Abstraction object also maintains a reference to an Implementor object. The collaboration between the objects in this pattern is such that the client's requests are forwarded by the Abstraction to the Implementor through this reference. A RefinedAbstraction, then, is simply any and all extensions to the Abstraction class. The Implementor defines the interface for any and all implementations of the Abstraction. 

Suppose we have to develop an Image Viewer application to view BMP files under Windows OS. At the same time, we have to extend it to view other image formats like JPEG, JPG etc under Windows OS. 

The class structure for the above scenario may be like.  



Where Image is an abstract class or interface and BMPImage, JPGImage & JPEGImage are concrete classes.  Now we have to modify the class hierarchy so that we have to use the Image for other OS like LINUX or UNIX. With the above class hierarchy it is pretty difficult. But by decoupling the abstraction and implementation we can achieve this as shown below. 



The client always uses an instance of Image. Depending on the OS, the client can configure Image sub classes with a concrete ImgImp object. 

The bridge design pattern lets the abstraction and its implementation evolve separately. 

C# Implementation

// Structural Pattern:BRIDGE
using System;
//Base class for OS implemenations
interface ImageImp
{
void DoPaint(string str);
}
//Windows specific implemenation
class WinImp : ImageImp
{
public void DoPaint(string str)
{
Console.WriteLine(str+" WIN OS");
}
}
//Abstract class for all image paintings
class Image
{
public void SetImageImp(ImageImp ip)
{
impToUse = ip;
}
public virtual void Method(string s1)
{
}
protected ImageImp impToUse;
}
//BMP specific paintings
class BMPImage : Image
{
override public void Method(string s1)
{
string s2 = s1 + " BMP IMAGE";
impToUse.DoPaint(s2);
}
}
//Client
class MyPaint
{
public Image SetUpMethod()
{
Image im = new BMPImage(); // BMP IMAGE
ImageImp win = new WinImp();// WIN OS
im.SetImageImp(win);
return im;
}
}
class MyMain
{
public static void Main()
{
MyPaint mp = new MyPaint();
Image im = mp.SetUpMethod();
im.Method("PAINTING-->");
}
}