Abstract Factory Design Pattern

Abstract factory pattern is categorized under creational design pattern that focuses on families of related object creation without exposing its internal logic.

In an abstract factory pattern, families of related objects are created without specifying their exact classes. It defines an interface for creating a set of related objects and allows different implementations of the factory to create different sets of related objects. 


Possible use cases for abstract factory pattern 

Here are some possible use cases for the Abstract Factory pattern

1. GUI Toolkits
Abstract Factory pattern is frequently used in GUI toolkits, where different UI components like buttons, text boxes, and menus need to be created for different platforms such as Windows, Mac, or Linux.

2. Database Drivers
Abstract Factory pattern can be used to create database drivers that support different databases like Oracle, MySQL, and SQL Server. The abstract factory can create a family of related objects like Connection, Statement, and ResultSet for each database.

3. Mobile App Development
Abstract Factory pattern can be used in mobile app development where different versions of the same app need to be created for different operating systems like iOS and Android. The abstract factory can create platform-specific UI components, APIs, and services.

4. Game Development
Abstract Factory patterns can be used in game development to create different types of objects like characters, weapons, and levels for different game genres like action, adventure, or strategy.

5. E-commerce Websites
Abstract Factory pattern can be used in e-commerce websites to create product catalogs for different categories like electronics, clothing, or books. The abstract factory can create a family of related objects like product images, descriptions, and reviews for each category.

Implementation

Implementation of the abstract factory pattern includes the following steps 

1. Create Interfaces for the productA and productB as shown 

  1. //Interface for the product A   
  2. public interface IProductA
  3. {
  4.     void ShowProductInfo();
  5. }

  7.  //Interface for the product B   
  8. public interface IProductB
  9. {
  10.     void ShowProductInfo();
  11. }


2. Create concrete classes for the interface as shown 

  1.  
  2.  //Concrete classes for product A  
  3. public class ProductA1 : IProductA
  4. {
  5.     public void ShowProductInfo()
  6.     {
  7.         Console.WriteLine("ProductA1 created");
  8.     }
  9. }

  11. public class ProductA2 : IProductA
  12. {
  13.     public void ShowProductInfo()
  14.     {
  15.         Console.WriteLine("ProductA2 created");
  16.     }
  17. }

  19.  //Concrete classes for product B
  20. public class ProductB1 : IProductB
  21. {
  22.     public void ShowProductInfo()
  23.     {
  24.         Console.WriteLine("ProductB1 created");
  25.     }
  26. } 

  28.  
  29. public class ProductB2 : IProductB
  30. {
  31.     public void ShowProductInfo()
  32.     {
  33.         Console.WriteLine("ProductB2 created");
  34.     }
  35. } 
 


3. Create an abstract factory with the help of an interface and classes which implements that interface and contains the logic of object creation as shown.

  1.  
  2. // Interface for the factory 
  3. public interface IProductFactory
  4. {
  5.     IProductA CreateProductA();
  6.     IProductB CreateProductB();
  7. }
  9. // Concrete classes for the factory 
  10. public class ProductFactory1 : IProductFactory
  11. {
  12.     public IProductA CreateProductA()
  13.     {
  14.         return new ProductA1();
  15.     }

  17.     public IProductB CreateProductB()
  18.     {
  19.         return new ProductB1();
  20.     }
  21. }


  24. public class ProductFactory2 : IProductFactory
  25. {
  26.     public IProductA CreateProductA()
  27.     {
  28.         return new ProductA2();
  29.     }

  31.     public IProductB CreateProductB()
  32.     {
  33.         return new ProductB2();
  34.     }
  35. }


4. Now create client class that uses the abstract factory as shown below.


  2.  //Client code that uses the abstract factory
  4. public class Client
  5. {
  6.     private IProductA _productA;
  7.     private IProductB _productB;

  9.     public Client(IProductFactory factory)
  10.     {
  11.         _productA = factory.CreateProductA();
  12.         _productB = factory.CreateProductB();

  14.     }

  16.     public void Run()
  17.     {
  18.         _productA.ShowProductInfo();
  19.         _productB.ShowProductInfo();
  20.     }
  21. }

5. You can now create different factories and use them to create the appropriate products:


  2. ProductFactory factory = new ProductFactory();
  4. IProductFactory factory1 = new ProductFactory1();

  6. Client client1 = new Client(factory1);

  8. //Creates ProductA1 and ProductB1
  9. client1.Run();

  11. IProductFactory factory2 = new ProductFactory2();

  13. Client client2 = new Client(factory2);

  15. //Creates ProductA2 and ProductB2
  16. client2.Run(); 


Advantages of Abstract Factory Pattern

1. Centralized related set of object creation logic that helps in code manageability.

2. Provides a level of abstraction for object creation.


Versioning in Abstract Factory Pattern

Handling versioning in an Abstract Factory implementation can be challenging, but there are several approaches that can be used depending on the specific requirements of the system. 

Here are some strategies that can be used

1. Versioning at the factory level

In this approach, each concrete factory is assigned a version number, and the abstract factory is modified to return the appropriate concrete factory based on the version number. This approach works well when there are only a few concrete factories, and the differences between versions are relatively minor.


2. Versioning at the product level

In this approach, each product returned by the abstract factory is assigned a version number, and the abstract factory is modified to return the appropriate version of the product based on the version number. This approach is more flexible than versioning at the factory level but can be more complex to implement.


3. Versioning through inheritance

In this approach, a new version of a product is created by subclassing the existing product, and the abstract factory is modified to return the appropriate subclass based on the version number. This approach works well when there are a large number of products, and the differences between versions are significant.


Here is an example of how versioning might be handled in an Abstract Factory implementation

Suppose you have an abstract factory called ReportFactory, which returns two products: Report and ReportTemplate. You want to introduce a new version of the Report product that includes additional data fields.

One approach to versioning at the product level could be to add a version parameter to the CreateReport method in the ReportFactory interface, like this

  1. // Interface for the factory 
  2. public interface IReportFactory 
  3. {
  4.     Report CreateReport(int version);
  5.     ReportTemplate CreateReportTemplate()
  6. }


The concrete factories implementing this interface would then check the version parameter and return the appropriate version of the Report product. For example:


  1. // Concrete classes for the factory for version 1 
  2. public class ReportFactoryV1 : IReportFactory 
  3. {
  4.     public Report CreateReport(int version)
  5.     {
  6.         return new ReportV1();
  7.     }

  9.     public ReportTemplate createReportTemplate()
  10.     {
  11.         return new ReportTemplateV1();
  12.     }
  13. }


  1. // Concrete classes for the factory for version 2 
  2. public class ReportFactoryV2 : IReportFactory 
  3. {
  4.     public Report CreateReport(int version)
  5.     { 
  6.        if(version == 2) 
  7.        {   
  8.         return new ReportV1();
  9.        }
  10.        else  
  11.        {   
  12.         return new ReportV1();
  13.        }
  14.     }

  16.     public ReportTemplate createReportTemplate()
  17.     {
  18.         return new ReportTemplateV2();
  19.     }
  20. }

In this example, the ReportV2 class would be a subclass of ReportV1, with additional data fields.

With this approach, clients of the ReportFactory interface can request a specific version of the Report product by passing in the version number when calling the createReport method.



Comments

Post a Comment

Popular posts from this blog

Design Patterns

Image
Design patterns are a collection of reusable solutions to complex design problems in software development which evolved over time and widely accepted as the best way to address certain design challenges. They're more suitable when building an application prototype or working on large and complex projects. Design patterns are classified into three categories based on the type of problem they can solve  1. Creational design patterns  2. Structural  design patterns  3. Behavioral design patterns  Creational design patterns Creational design patterns are a type of design pattern that focus on creating objects in a way that is flexible, reusable, and efficient. These patterns provide a set of guidelines for creating objects and managing their lifecycle, helping to ensure that objects are created and used in a consistent and effective way.  Some most common examples of creation design patterns are  1.  Singleton pattern 2. Factory pattern 3. Abstra...
Read more

Azure Container Registry (ACR)

Image
Azure Container Registry (ACR) is a managed Docker registry service provided by Microsoft Azure. It is used to store and manage container images for use in Azure Kubernetes Service (AKS), Azure Web Apps, and other container-based services. ACR works by providing a secure and highly available repository for storing container images. It supports both public and private image repositories, which can be accessed by users with appropriate permissions. Users can push container images to the registry, and then pull them for use in their applications. How to Setup Azure Container Registry(ACR) To set up an Azure Container Registry (ACR), follow these steps 1. Log in to the Azure Portal (https://portal.azure.com/). 2. Click on the "+ Create a resource" button in the left-hand menu, and then search for "Container Registry" in the search box. 3. Click on "Container Registry" in the results and then click on the "Create" button. 4. In the "Basics" ...
Read more

Factory Design Pattern

Factory pattern is categorized under creational design pattern that focuses on object creation without exposing its internal logic. In factory pattern, objects are created without specifying its exact class. It defines an interface for creating objects, and allows subclasses to decide which class of object to create.  Possible use cases for factory pattern  Here are some possible use cases for the Factory pattern 1. Object creation with a common interface  If you need to create multiple objects that implement a common interface, a factory pattern can be used to abstract the creation of the objects. 2. Object creation with complex initialization  If object creation involves complex initialization, a factory pattern can be used to abstract the initialization process and make it simpler. 3. Object creation with conditional logic  If object creation requires conditional logic, a factory pattern can be used to encapsulate the logic in a factory method, making it easi...
Read more

What is Azure DevOps?

Azure DevOps is a set of practices that collaborate development(Dev) and operation(Ops) team to work closely along with the tools which are optimized for this collaboration aiming to increase the ability to develop applications faster than the traditional software development process.  DevOps lifecycle includes initial software planning, code, build, test, release phases, operations, ongoing monitoring, customer feedback and improvement.  Components of Azure DevOps  The main components of Azure DevOps are  1. Azure DevOps Boards 2. Azure DevOps Repository  3. Azure DevOps Pipeline  4. Azure DevOps Test Plans  5. Azure Artifacts Azure DevOps boards Azure board is one of the main component of azure DevOps that helps in managing the work for the project under development. Azure DevOps board main features are  Work Item  Its a defined unit of work along with some important attributes like the type of work, its severity, estimated time to com...
Read more