Software Dev/03 - Factory Method.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Factory Method\n",
    "\n",
    "## General idea\n",
    "The Factory Method pattern is a creational design pattern that provides an interface for creating objects, but delegates the actual object creation to subclasses. It allows the subclasses to decide which class to instantiate while adhering to a common interface or base class. The Factory Method pattern promotes loose coupling and enhances flexibility in object creation.\n",
    "\n",
    "## Benefits\n",
    "The Factory Method pattern provides several benefits:\n",
    "\n",
    "- Encapsulation: The Factory Method pattern encapsulates the object creation logic within the factory method and its subclasses. Clients only need to interact with the factory method and are shielded from the complexities of object creation.\n",
    "\n",
    "- Loose Coupling: The pattern promotes loose coupling between the client code and the actual object creation process. Clients depend on the factory method interface or base class, reducing dependencies on specific concrete classes.\n",
    "\n",
    "- Extensibility: The Factory Method pattern allows for easy extension by introducing new subclasses that implement the factory method. This makes it straightforward to add new product types without modifying existing client code.\n",
    "\n",
    "- Flexibility: The pattern enables the selection of concrete classes to be instantiated at runtime. The decision on which subclass to use can be based on configuration, user input, or other runtime factors. This flexibility makes it possible to customize the object creation process dynamically.\n",
    "\n",
    "- Testability: The Factory Method pattern improves testability by facilitating the creation of mock or stub objects for testing purposes. Subclasses of the factory method can be replaced with test-specific implementations to isolate the code being tested.\n",
    "\n",
    "- Code Organization: The pattern helps organize code by separating object creation logic from other business logic. The factory method and its subclasses provide a clear and structured way to handle object creation, improving code readability and maintainability.\n",
    "\n",
    "> The Factory Method pattern is widely used in various scenarios, such as framework development, dependency injection, plugin systems, and more. It enables developers to decouple object creation from client code, promoting modular and extensible software design\n",
    "\n",
    "## How it works\n",
    "- Define an abstract base class or interface that declares the factory method. This method serves as the common interface for creating objects.\n",
    "\n",
    "- Create concrete subclasses that implement the factory method. Each subclass decides which concrete class to instantiate and return as a product.\n",
    "\n",
    "- Clients use the factory method to create objects, without knowing the specific class that is being instantiated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Example of implementation of factory method pattern in C#\n",
    "\n",
    "// Abstract Product\n",
    "public abstract class Product\n",
    "{\n",
    "    public abstract void Operation();\n",
    "}\n",
    "\n",
    "// Concrete Products\n",
    "public class ConcreteProductA : Product\n",
    "{\n",
    "    public override void Operation()\n",
    "    {\n",
    "        Console.WriteLine(\"ConcreteProductA operation.\");\n",
    "    }\n",
    "}\n",
    "\n",
    "public class ConcreteProductB : Product\n",
    "{\n",
    "    public override void Operation()\n",
    "    {\n",
    "        Console.WriteLine(\"ConcreteProductB operation.\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Abstract Creator\n",
    "public abstract class Creator\n",
    "{\n",
    "    public abstract Product CreateProduct();\n",
    "    \n",
    "    public void SomeOperation()\n",
    "    {\n",
    "        Product product = CreateProduct();\n",
    "        product.Operation();\n",
    "    }\n",
    "}\n",
    "\n",
    "// Concrete Creators\n",
    "public class ConcreteCreatorA : Creator\n",
    "{\n",
    "    public override Product CreateProduct()\n",
    "    {\n",
    "        return new ConcreteProductA();\n",
    "    }\n",
    "}\n",
    "\n",
    "public class ConcreteCreatorB : Creator\n",
    "{\n",
    "    public override Product CreateProduct()\n",
    "    {\n",
    "        return new ConcreteProductB();\n",
    "    }\n",
    "}\n",
    "\n",
    "// Client\n",
    "public class Client\n",
    "{\n",
    "    public void Code()\n",
    "    {\n",
    "        Creator creatorA = new ConcreteCreatorA();\n",
    "        creatorA.SomeOperation();\n",
    "\n",
    "        Creator creatorB = new ConcreteCreatorB();\n",
    "        creatorB.SomeOperation();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In this example:\n",
    "\n",
    "- The `Product` class is the abstract base class representing the products that the factory methods create. It defines the Operation method, which is overridden by the concrete product classes.\n",
    "\n",
    "- The concrete product classes (`ConcreteProductA` and `ConcreteProductB`) implement the Operation method specific to their behavior.\n",
    "\n",
    "- The `Creator` class is the abstract base class defining the factory method `CreateProduct()`. It also provides a common operation `SomeOperation()` that uses the factory method to create and operate on a product.\n",
    "\n",
    "- The concrete creator classes (`ConcreteCreatorA` and `ConcreteCreatorB`) inherit from the `Creator` class and override the `CreateProduct` method to instantiate a specific product.\n",
    "\n",
    "- The `Client` class demonstrates how the factory method pattern is used. It creates instances of the concrete creator classes and calls the `SomeOperation` method, which internally uses the factory method to create and operate on the products.\n",
    "\n",
    "> By using the Factory Method pattern, the client code is decoupled from the specific product creation logic. The concrete creators are responsible for creating instances of the products, while the client code interacts with the abstract creator and product interfaces. This provides flexibility, extensibility, and loose coupling between the client code and the specific product implementations."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}