C# | Factory Design Pattern | Creational Design Pattern

Defines an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

This structural code demonstrates the Factory method offering great flexibility in creating different objects. The Abstract class may provide a default object, but each subclass can instantiate an extended version of the object.



Code Syntax -

public interface ICar
{
    void Start();
}

public class SixSeater : ICar
{
    public void Start()
    {
        throw new NotImplementedException();
    }
}

public class FourSeater : ICar
{
    public void Start()
    {
        throw new NotImplementedException();
    }
}

public class CarFactory
{
    public ICar GetCar(string carType)
    { 
        switch(carType)
        {
            case "SixSeater":
                return new SixSeater();

            case "FourSeater":
                return new FourSeater();
        }
        return null;
    }
}

internal class Program
{
    static void Main(string[] args)
    {
        CarFactory factory = new CarFactory();
        ICar sixSeater = factory.GetCar("SixSeater");
        ICar fourSeater = factory.GetCar("FourSeater");
    }
}

When to use it?

The process of objects creation is required to centralize within the application.

A class (creator) will not know what classes it will be required to create.


Comments

Post a Comment

Popular posts from this blog

C# | SOLID Principles

Image
  SOLID stands for: S = Single Responsibility Principle O = Open/Closed Principle L = Liskov Substitution Principle I = Interface Segregation Principle D = Dependency Inversion Principle Solid Principles Single Responsibility Principle Each software module should have one and only one reason to change. The Single Responsibility Principle is the first principle of SOLID principles. It is the fundamental principle of object-oriented programming that determines how we should design classes. The Single Responsibility Principle states that: Each software module should have one and only one reason to change. In other words, a class should have only one responsibility and therefore it should have only one reason to change its code. If a class has more than one responsibility, then there will be more than one reason to change the class (code). Now, the question is what is responsibility? An application can have many functionalities (features). For example, an online e-commerce application ...
Read more

C# | Chain of Responsibility Design Pattern | Behavioral Design Pattern

Image
The chain of responsibility pattern creates a chain of receiver objects for a request. This pattern decouples sender and receiver of a request based on type of request. This pattern comes under behavioral patterns. In this pattern, normally each receiver contains reference to another receiver. If one object cannot handle the request, then it passes the same to the next receiver and so on. UML Diagram - Who is what? The classes, interfaces and objects in the above class diagram can be identified as follows: 1.       Approver - Handler abstract class. 2.       Clerk, Assistant Manager & Manager - ConcreteHandler classes. 3.       Loan & LoanEventArgs - These classes are used for internal processing and holds request details.
Read more