Bridge Design Pattern - C#

Bridge pattern falls under Structural Pattern of Gang of Four (GOF) Design Patterns in .Net. All we know, Inheritance is a way to specify different implementations of an abstraction. But in this way, implementations are tightly bound to the abstraction and can not be modified independently. The Bridge pattern provides an alternative to inheritance when there are more than one version of an abstraction. In this article, I would like share what is bridge pattern and how is it work?

What is Bridge Pattern

Bridge pattern is used to separate an abstraction from its implementation so that both can be modified independently.
This pattern involves an interface which acts as a bridge between the abstraction class and implementer classes and also makes the functionality of implementer class independent from the abstraction class. Both types of classes can be modified without affecting to each other.

Bridge Pattern - UML Diagram & Implementation

The UML class diagram for the implementation of the bridge design pattern is given below:

The classes, interfaces and objects in the above UML class diagram are as follows:

1. Abstraction

   This is an abstract class and containing members that define an abstract business object and its functionality. It contains a reference to an object of type Bridge. It can also acts as the base class for other abstractions.

2. Redefined Abstraction

   This is a class which inherits from the Abstraction class. It extends the interface defined by Abstraction class.

3. Bridge

   This is an interface which acts as a bridge between the abstraction class and implementer classes and also makes the functionality of implementer class independent from the abstraction class.

4. ImplementationA & ImplementationB

   These are classes which implement the Bridge interface and also provide the implementation details for the associated Abstraction class.

C# - Implementation Code

public abstract class Abstraction
{
 public Bridge Implementer { get; set; }
 
 public virtual void Operation()
 {
 Console.WriteLine("ImplementationBase:Operation()");
 Implementer.OperationImplementation();
 }
}
 
public class RefinedAbstraction : Abstraction
{
 public override void Operation()
 {
 Console.WriteLine("RefinedAbstraction:Operation()");
 Implementer.OperationImplementation();
 }
}
 
public interface Bridge
{
 void OperationImplementation();
}
 
public class ImplementationA : Bridge
{
 public void OperationImplementation()
 {
 Console.WriteLine("ImplementationA:OperationImplementation()");
 }
}
 
public class ImplementationB : Bridge
{
 public void OperationImplementation()
 {
 Console.WriteLine("ImplementationB:OperationImplementation()");
 }
}

Bridge Pattern - Example

Who is what?

The classes, interfaces and objects in the above class diagram can be identified as follows:

1. Message - Abstraction Class.
2. SystemMessage & UserMessage- Redefined Abstraction Classes.
3. IMessageSender- Bridge Interface.
4. EmailSender, WebServiceSender & MSMQ Sender- ConcreteImplementation class which implements the IMessageSender interface.

C# - Sample Code

/// <summary>
/// The 'Abstraction' class
/// </summary>
public abstract class Message
{
 public IMessageSender MessageSender { get; set; }
 public string Subject { get; set; }
 public string Body { get; set; }
 public abstract void Send();
}
 
/// <summary>
/// The 'RefinedAbstraction' class
/// </summary>
public class SystemMessage : Message
{
 public override void Send()
 {
 MessageSender.SendMessage(Subject, Body);
 }
}
 
/// <summary>
/// The 'RefinedAbstraction' class
/// </summary>
public class UserMessage : Message
{
 public string UserComments { get; set; }
 
 public override void Send()
 {
 string fullBody = string.Format("{0}\nUser Comments: {1}", Body, UserComments);
 MessageSender.SendMessage(Subject, fullBody);
 }
}
 
/// <summary>
/// The 'Bridge/Implementor' interface
/// </summary>
public interface IMessageSender
{
 void SendMessage(string subject, string body);
}
 
/// <summary>
/// The 'ConcreteImplementor' class
/// </summary>
public class EmailSender : IMessageSender
{
 public void SendMessage(string subject, string body)
 {
 Console.WriteLine("Email\n{0}\n{1}\n", subject, body);
 }
}
 
/// <summary>
/// The 'ConcreteImplementor' class
/// </summary>
public class MSMQSender : IMessageSender
{
 public void SendMessage(string subject, string body)
 {
 Console.WriteLine("MSMQ\n{0}\n{1}\n", subject, body);
 }
}
 
/// <summary>
/// The 'ConcreteImplementor' class
/// </summary>
public class WebServiceSender : IMessageSender
{
 public void SendMessage(string subject, string body)
 {
 Console.WriteLine("Web Service\n{0}\n{1}\n", subject, body);
 }
}
 
/// <summary>
/// Bridge Design Pattern Demo
/// </summary>
class Program
{
 static void Main(string[] args)
 {
 IMessageSender email = new EmailSender();
 IMessageSender queue = new MSMQSender();
 IMessageSender web = new WebServiceSender();
 
 Message message = new SystemMessage();
 message.Subject = "Test Message";
 message.Body = "Hi, This is a Test Message";
 
 message.MessageSender = email;
 message.Send();
 
 message.MessageSender = queue;
 message.Send();
 
 message.MessageSender = web;
 message.Send();
 
 UserMessage usermsg = new UserMessage();
 usermsg.Subject = "Test Message";
 usermsg.Body = "Hi, This is a Test Message";
 usermsg.UserComments = "I hope you are well";
 
 usermsg.MessageSender = email;
 usermsg.Send();
 
 Console.ReadKey();
 }
}

Bridge Pattern Demo - Output

When to use it?

1. Abstractions and implementations should be modified independently.
2. Changes in the implementation of an abstraction should have no impact on clients.
3. The Bridge pattern is used when a new version of a software or system is brought out, but the older version of the software still running for its existing client. There is no need to change the client code, but the client need to choose which version he wants to use.

Note

Bridge pattern has nearly the same structure as the Adapter Pattern. But it is used when designing new systems instead of the Adapter pattern which is used with already existing systems.

What do you think?

I hope you will enjoy the bridge Pattern while designing your software. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.

Adapter Design Pattern - C#

Adapter pattern falls under Structural Pattern of Gang of Four (GOF) Design Patterns in .Net. The Adapter pattern allows a system to use classes of another system that is incompatible with it. It is especially used for toolkits and libraries. In this article, I would like share what is adapter pattern and how is it work?

What is Adapter Pattern

Adapter pattern acts as a bridge between two incompatible interfaces. This pattern involves a single class called adapter which is responsible for communication between two independent or incompatible interfaces.
For Example: A card reader acts as an adapter between memory card and a laptop. You plugins the memory card into card reader and card reader into the laptop so that memory card can be read via laptop.

Adapter Pattern - UML Diagram & Implementation

The UML class diagram for the implementation of the Adapter design pattern is given below:

The classes, interfaces and objects in the above UML class diagram are as follows:

1. ITarget

   This is an interface which is used by the client to achieve its functionality/request.

2. Adapter

   This is a class which implements the ITarget interface and inherits the Adaptee class. It is responsible for communication between Client and Adaptee.

3. Adaptee

   This is a class which have the functionality, required by the client. However, its interface is not compatible with the client.

4. Client

   This is a class which interact with a type that implements the ITarget interface. However, the communication class called adaptee, is not compatible with the client

C# - Implementation Code

public class Client
{
 private ITarget target;
 
 public Client(ITarget target)
 {
 this.target = target;
 }
 
 public void MakeRequest()
 {
 target.MethodA();
 }
}
 
public interface ITarget
{
 void MethodA();
}
 
public class Adapter : Adaptee, ITarget
{
 public void MethodA()
 {
 MethodB();
 }
}
 
public class Adaptee
{
 public void MethodB()
 {
 Console.WriteLine("MethodB() is called");
 }
}

Adapter Pattern - Example

Who is what?

The classes, interfaces and objects in the above class diagram can be identified as follows:

1. ITraget - Target interface
2. Employee Adapter- Adapter Class
3. HR System- Adaptee Class
4. ThirdPartyBillingSystem - Client

C# - Sample Code

/// <summary>
/// The 'Client' class
/// </summary>
public class ThirdPartyBillingSystem
{
 private ITarget employeeSource;
 
 public ThirdPartyBillingSystem(ITarget employeeSource)
 {
 this.employeeSource = employeeSource;
 }
 
 public void ShowEmployeeList()
 {
 List<string> employee = employeeSource.GetEmployeeList();
 //To DO: Implement you business logic
 
 Console.WriteLine("######### Employee List ##########");
 foreach (var item in employee)
 {
 Console.Write(item); 
 }
 
 }
}
 
/// <summary>
/// The 'ITarget' interface
/// </summary>
public interface ITarget
{
 List<string> GetEmployeeList();
}
 
/// <summary>
/// The 'Adaptee' class
/// </summary>
public class HRSystem
{
 public string[][] GetEmployees()
 {
 string[][] employees = new string[4][];
 
 employees[0] = new string[] { "100", "Deepak", "Team Leader" };
 employees[1] = new string[] { "101", "Rohit", "Developer" };
 employees[2] = new string[] { "102", "Gautam", "Developer" };
 employees[3] = new string[] { "103", "Dev", "Tester" };
 
 return employees;
 }
}
 
/// <summary>
/// The 'Adapter' class
/// </summary>
public class EmployeeAdapter : HRSystem, ITarget
{
 public List<string> GetEmployeeList()
 {
 List<string> employeeList = new List<string>();
 string[][] employees = GetEmployees();
 foreach (string[] employee in employees)
 {
 employeeList.Add(employee[0]);
 employeeList.Add(",");
 employeeList.Add(employee[1]);
 employeeList.Add(",");
 employeeList.Add(employee[2]);
 employeeList.Add("\n");
 }
 
 return employeeList;
 }
}
 
/// 

/// Adapter Design Pattern Demo
/// 
class Program
{
 static void Main(string[] args)
 {
 ITarget Itarget = new EmployeeAdapter();
 ThirdPartyBillingSystem client = new ThirdPartyBillingSystem(Itarget);
 client.ShowEmployeeList();
 
 Console.ReadKey();
 
 }
}

Adapter Pattern Demo - Output

When to use it?

1. Allow a system to use classes of another system that is incompatible with it.
2. Allow communication between new and already existing system which are independent to each other
3. Ado.Net SqlAdapter, OracleAdapter, MySqlAdapter are best example of Adapter Pattern.

Note

1. Internally, Adapter use Factory design pattern for creating objects. But it can also use Builder design pattern and prototype design pattern for creating product. It completely depends upon your implementation for creating products.
2. Adapter can be used as an alternative to Facade to hide platform-specific classes.
3. When Adapter, Builder, and Prototype define a factory for creating the products, we should consider the following points :
   
   1. Adapter use the factory for creating objects of several classes.
   2. Builder use the factory for creating a complex product by using simple objects and a step by step approach.
   3. Prototype use the factory for building a product by copying an existing product.

What do you think?

I hope you will enjoy the Adapter Pattern while designing your software. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.

Singleton Design Pattern - C#

Singleton pattern falls under Creational Pattern of Gang of Four (GOF) Design Patterns in .Net. It is pattern is one of the simplest design patterns. This pattern ensures that a class has only one instance. In this article, I would like share what is Singleton pattern and how is it work?

What is Singleton Pattern?

Singleton pattern is one of the simplest design patterns. This pattern ensures that a class has only one instance and provides a global point of access to it.

Singleton Pattern - UML Diagram & Implementation

The UML class diagram for the implementation of the Singleton design pattern is given below:

The classes, and objects in the above UML class diagram are as follows:

1. Singleton

   This is a class which is responsible for creating and maintaining its own unique instance.

C# - Implementation Code

//eager initialization of singleton
public class Singleton
{
 private static Singleton instance = new Singleton();
 private Singleton() { }
 
 public static Singleton GetInstance
 {
 get
 {
 return instance;
 }
 }
}
 
////lazy initialization of singleton
public class Singleton
{
 private static Singleton instance = null;
 private Singleton() { }
 
 public static Singleton GetInstance
 {
 get
 {
 if (instance == null)
 instance = new Singleton();
 
 return instance;
 }
 }
}
 
////Thread-safe (Double-checked Locking) initialization of singleton
public class Singleton
{
 private static Singleton instance = null;
 private Singleton() { }
 private static object lockThis = new object();
 
 public static Singleton GetInstance
 {
 get
 {
 lock (lockThis)
 {
 if (instance == null)
 instance = new Singleton();
 
 return instance;
 }
 }
 }
}

Singleton Pattern - Example

Who is what?

The classes and objects in the above class diagram can be identified as follows:

1. Singleton - Singleton class

C# - Sample Code

/// <summary>
/// The 'Singleton' class
/// </summary>
public class Singleton
{
 // .NET guarantees thread safety for static initialization
 private static Singleton instance = null;
 private string Name{get;set;}
 private string IP{get;set;}
 private Singleton()
 {
 //To DO: Remove below line
 Console.WriteLine("Singleton Intance");
 
 Name = "Server1";
 IP = "192.168.1.23";
 }
 // Lock synchronization object
 private static object syncLock = new object();
 
 public static Singleton Instance
 {
 get
 {
 // Support multithreaded applications through
 // 'Double checked locking' pattern which (once
 // the instance exists) avoids locking each
 // time the method is invoked
 lock (syncLock)
 {
 if (Singleton.instance == null)
 Singleton.instance = new Singleton();
 
 return Singleton.instance;
 }
 }
 }
 
 public void Show()
 {
 Console.WriteLine("Server Information is : Name={0} & IP={1}", IP, Name);
 }
 
}
 
/// <summary>
/// Singleton Pattern Demo
/// </summary>
/// 
class Program
{
 static void Main(string[] args)
 {
 Singleton.Instance.Show();
 Singleton.Instance.Show();
 
 Console.ReadKey();
 }
}

Singleton Pattern Demo - Output

When to use it?

1. Exactly one instance of a class is required.
2. Controlled access to a single object is necessary.

What do you think?

I hope you will enjoy the Singleton Pattern while designing your software. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.

Prototype Design Pattern - C#

Prototype pattern falls under Creational Pattern of Gang of Four (GOF) Design Patterns in .Net. It is used to used to create a duplicate object or clone of the current object. It provides an interface for creating parts of a product. In this article, I would like share what is Prototype pattern and how is it work?

What is Prototype Pattern?

Prototype pattern is used to create a duplicate object or clone of the current object to enhance performance. This pattern is used when creation of object is costly or complex.
For Example: An object is to be created after a costly database operation. We can cache the object, returns its clone on next request and update the database as and when needed thus reducing database calls.

Prototype Pattern - UML Diagram & Implementation

The UML class diagram for the implementation of the Prototype design pattern is given below:

The classes, interfaces and objects in the above UML class diagram are as follows:

1. Prototype

   This is an interface which is used for the types of object that can be cloned itself.

2. ConcretePrototype

   This is a class which implements the Prototype interface for cloning itself.

C# - Implementation Code

public interface Prototype
{
 Prototype Clone();
}
 
public class ConcretePrototypeA : Prototype
{
 public Prototype Clone()
 {
 // Shallow Copy: only top-level objects are duplicated
 return (Prototype)MemberwiseClone();
 
 // Deep Copy: all objects are duplicated
 //return (Prototype)this.Clone();
 }
}
 
public class ConcretePrototypeB : Prototype
{
 public Prototype Clone()
 {
 // Shallow Copy: only top-level objects are duplicated
 return (Prototype)MemberwiseClone();
 
 // Deep Copy: all objects are duplicated
 //return (Prototype)this.Clone();
 }
}

Prototype Pattern - Example

Who is what?

The classes, interfaces and objects in the above class diagram can be identified as follows:

1. IEmployee - Prototype interface
2. Developer & Typist- Concrete Prototype

C# - Sample Code

/// <summary>
/// The 'Prototype' interface
/// </summary>
public interface IEmployee
{
 IEmployee Clone();
 string GetDetails();
}
 
/// <summary>
/// A 'ConcretePrototype' class
/// </summary>
public class Developer : IEmployee
{
 public int WordsPerMinute { get; set; }
 public string Name { get; set; }
 public string Role { get; set; }
 public string PreferredLanguage { get; set; }
 
 public IEmployee Clone()
 {
 // Shallow Copy: only top-level objects are duplicated
 return (IEmployee)MemberwiseClone();
 
 // Deep Copy: all objects are duplicated
 //return (IEmployee)this.Clone();
 }
 
 public string GetDetails()
 {
 return string.Format("{0} - {1} - {2}", Name, Role, PreferredLanguage);
 }
}
 
/// <summary>
/// A 'ConcretePrototype' class
/// </summary>
public class Typist : IEmployee
{
 public int WordsPerMinute { get; set; }
 public string Name { get; set; }
 public string Role { get; set; }
 
 public IEmployee Clone()
 {
 // Shallow Copy: only top-level objects are duplicated
 return (IEmployee)MemberwiseClone();
 
 // Deep Copy: all objects are duplicated
 //return (IEmployee)this.Clone();
 }
 
 public string GetDetails()
 {
 return string.Format("{0} - {1} - {2}wpm", Name, Role, WordsPerMinute);
 }
}
 
/// <summary>
/// Prototype Pattern Demo
/// </summary>
 
class Program
{
 static void Main(string[] args)
 {
 Developer dev = new Developer();
 dev.Name = "Rahul";
 dev.Role = "Team Leader";
 dev.PreferredLanguage = "C#";
 
 Developer devCopy = (Developer)dev.Clone();
 devCopy.Name = "Arif"; //Not mention Role and PreferredLanguage, it will copy above
 
 Console.WriteLine(dev.GetDetails());
 Console.WriteLine(devCopy.GetDetails());
 
 Typist typist = new Typist();
 typist.Name = "Monu";
 typist.Role = "Typist";
 typist.WordsPerMinute = 120;
 
 Typist typistCopy = (Typist)typist.Clone();
 typistCopy.Name = "Sahil";
 typistCopy.WordsPerMinute = 115;//Not mention Role, it will copy above
 
 Console.WriteLine(typist.GetDetails());
 Console.WriteLine(typistCopy.GetDetails());
 
 Console.ReadKey();
 
 }
}

Prototype Pattern Demo - Output

When to use it?

1. The creation of each object is costly or complex.
2. A limited number of state combinations exist in an object.

What do you think?

I hope you will enjoy the Prototype Pattern while designing your software. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.

Builder Design Pattern - C#

Builder pattern falls under Creational Pattern of Gang of Four (GOF) Design Patterns in .Net. It is used to builds a complex object by using a step by step approach. It provides an interface for creating parts of a product. In this article, I would like share what is builder pattern and how is it work?

What is Builder Pattern?

Builder pattern builds a complex object by using a step by step approach. Builder interface defines the steps to build the final object. This builder is independent from the objects creation process. A class that is known as Director, controls the object creation process.
Moreover, builder pattern describes a way to separate an object from its construction. The same construction method can create different representation of the object.

Builder Pattern - UML Diagram & Implementation

The UML class diagram for the implementation of the builder design pattern is given below:

The classes, interfaces and objects in the above UML class diagram are as follows:

1. Builder

   This is an interface which is used to define all the steps to create a product

2. ConcreteBuilder

   This is a class which implements the Builder interface to create complex product.

3. Product

   This is a class which defines the parts of the complex object which are to be generated by the builder pattern.

4. Director

   This is a class which is used to construct an object using the Builder interface.

C# - Implementation Code

public interface IBuilder
{
 void BuildPart1();
 void BuildPart2();
 void BuildPart3();
 Product GetProduct();
}
 
public class ConcreteBuilder : IBuilder
{
 private Product _product = new Product();
 
 public void BuildPart1()
 {
 _product.Part1 = "Part 1";
 }
 
 public void BuildPart2()
 {
 _product.Part2 = "Part 2";
 }
 
 public void BuildPart3()
 {
 _product.Part3 = "Part 3";
 }
 
 public Product GetProduct()
 {
 return _product;
 }
}
 
public class Product
{
 public string Part1 { get; set; }
 public string Part2 { get; set; }
 public string Part3 { get; set; }
}
 
public class Director
{
 public void Construct(IBuilder IBuilder)
 {
 IBuilder.BuildPart1();
 IBuilder.BuildPart2();
 IBuilder.BuildPart3();
 }
}

Builder Pattern - Example

Who is what?

The classes, interfaces and objects in the above class diagram can be identified as follows:

1. IVehicleBuilder - Builder interface
2. HeroBuilder & HondaBuilder- Concrete Builder
3. Vehicle- Product
4. Vehicle Creator - Director

C# - Sample Code

/// <summary>
/// The 'Builder' interface
/// </summary>
public interface IVehicleBuilder
{
 void SetModel();
 void SetEngine();
 void SetTransmission();
 void SetBody();
 void SetAccessories();
 
 Vehicle GetVehicle();
}
 
/// <summary>
/// The 'ConcreteBuilder1' class
/// </summary>
public class HeroBuilder : IVehicleBuilder
{
 Vehicle objVehicle = new Vehicle();
 public void SetModel()
 {
 objVehicle.Model = "Hero";
 }
 
 public void SetEngine()
 {
 objVehicle.Engine = "4 Stroke";
 }
 
 public void SetTransmission()
 {
 objVehicle.Transmission = "120 km/hr";
 }
 
 public void SetBody()
 {
 objVehicle.Body = "Plastic";
 }
 
 public void SetAccessories()
 {
 objVehicle.Accessories.Add("Seat Cover");
 objVehicle.Accessories.Add("Rear Mirror");
 }
 
 public Vehicle GetVehicle()
 {
 return objVehicle;
 }
}
 
/// <summary>
/// The 'ConcreteBuilder2' class
/// </summary>
public class HondaBuilder : IVehicleBuilder
{
 Vehicle objVehicle = new Vehicle();
 public void SetModel()
 {
 objVehicle.Model = "Honda";
 }
 
 public void SetEngine()
 {
 objVehicle.Engine = "4 Stroke";
 }
 
 public void SetTransmission()
 {
 objVehicle.Transmission = "125 Km/hr";
 }
 
 public void SetBody()
 {
 objVehicle.Body = "Plastic";
 }
 
 public void SetAccessories()
 {
 objVehicle.Accessories.Add("Seat Cover");
 objVehicle.Accessories.Add("Rear Mirror");
 objVehicle.Accessories.Add("Helmet");
 }
 
 public Vehicle GetVehicle()
 {
 return objVehicle;
 }
}
 
/// <summary>
/// The 'Product' class
/// </summary>
public class Vehicle
{
 public string Model { get; set; }
 public string Engine { get; set; }
 public string Transmission { get; set; }
 public string Body { get; set; }
 public List<string> Accessories { get; set; }
 
 public Vehicle()
 {
 Accessories = new List<string>();
 }
 
 public void ShowInfo()
 {
 Console.WriteLine("Model: {0}", Model);
 Console.WriteLine("Engine: {0}", Engine);
 Console.WriteLine("Body: {0}", Body);
 Console.WriteLine("Transmission: {0}", Transmission);
 Console.WriteLine("Accessories:");
 foreach (var accessory in Accessories)
 {
 Console.WriteLine("\t{0}", accessory);
 }
 }
}
 
/// <summary>
/// The 'Director' class
/// </summary>
public class VehicleCreator
{
 private readonly IVehicleBuilder objBuilder;
 
 public VehicleCreator(IVehicleBuilder builder)
 {
 objBuilder = builder;
 }
 
 public void CreateVehicle()
 {
 objBuilder.SetModel();
 objBuilder.SetEngine();
 objBuilder.SetBody();
 objBuilder.SetTransmission();
 objBuilder.SetAccessories();
 }
 
 public Vehicle GetVehicle()
 {
 return objBuilder.GetVehicle();
 }
}
 
/// <summary>
/// Builder Design Pattern Demo
/// </summary>
class Program
{
 static void Main(string[] args)
 {
 var vehicleCreator = new VehicleCreator(new HeroBuilder());
 vehicleCreator.CreateVehicle();
 var vehicle = vehicleCreator.GetVehicle();
 vehicle.ShowInfo();
 
 Console.WriteLine("---------------------------------------------");
 
 vehicleCreator = new VehicleCreator(new HondaBuilder());
 vehicleCreator.CreateVehicle();
 vehicle = vehicleCreator.GetVehicle();
 vehicle.ShowInfo();
 
 Console.ReadKey();
 }
}

Builder Pattern Demo - Output

When to use it?

1. Need to create an object in several steps (a step by step approach).
2. The creation of objects should be independent from the way the object's parts are assembled.
3. Runtime control over the creation process is required.

What do you think?

I hope you will enjoy the Builder Pattern while designing your software. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.