Software Dev/05 - Prototype.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prototype\n",
    "\n",
    "## General idea\n",
    "The Prototype pattern is a creational design pattern that allows you to create copies, or clones, of existing objects without coupling the code to their specific classes. It involves creating a prototypical instance that serves as a blueprint for creating new objects by copying its properties and behaviors.\n",
    "\n",
    "## Benefits\n",
    "The Prototype pattern provides several benefits:\n",
    "\n",
    "- Flexibility in Object Creation: The Prototype pattern allows you to create new objects by cloning existing ones, providing an alternative to using constructors or factories. This can be useful when object creation is complex or when you want to create variations of objects based on existing ones.\n",
    "\n",
    "- Reduction of Object Creation Overhead: Creating objects from scratch can be time-consuming and resource-intensive. By using the Prototype pattern, you can clone existing objects, avoiding the overhead of object creation and initialization.\n",
    "\n",
    "- Simplified Object Initialization: Prototypes can serve as initialized instances with pre-set values, making object initialization more straightforward. The client can clone a prototype and modify only the necessary properties, reducing the complexity of object creation.\n",
    "\n",
    "- Extensibility and Dynamic Object Creation: The Prototype pattern allows for dynamic object creation by providing a mechanism for creating objects at runtime based on the prototype. It enables you to add new prototypes and create objects based on them without modifying the client code.\n",
    "\n",
    "- Encapsulation and Information Hiding: The Prototype pattern encapsulates the cloning behavior within the prototype objects, hiding the implementation details from the client code. The client only needs to know how to request a clone, not how the cloning process is implemented.\n",
    "\n",
    "- Fine-grained Object Copying: The Prototype pattern allows for deep or shallow cloning of objects, depending on the requirements. Deep cloning creates a new instance and copies all properties recursively, while shallow cloning creates a new instance and copies only the top-level properties. This flexibility enables you to control the copying behavior based on your specific needs.\n",
    "\n",
    "> The Prototype pattern is commonly used in scenarios where object creation is expensive or complex, and you need to create multiple similar objects. It promotes code reuse, simplifies object initialization, and allows for dynamic object creation. Additionally, it can improve performance and reduce resource usage by avoiding unnecessary object creation and initialization steps.\n",
    "\n",
    "## How it works\n",
    "- The `Prototype` interface declares a common method, usually named `Clone`, that allows objects to be cloned.\n",
    "\n",
    "- Concrete Prototype classes implement the `Prototype` interface and provide their specific implementation of the `Clone` method. They create a new instance of themselves and copy their properties and behaviors to the new object.\n",
    "\n",
    "- The `Client` class creates new objects by requesting clones from a prototype instance. Instead of creating objects directly, the client can clone existing objects and modify them as needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Example of implementation of prototype pattern in C#\n",
    "\n",
    "// Prototype interface\n",
    "public interface IPrototype\n",
    "{\n",
    "    IPrototype Clone();\n",
    "}\n",
    "\n",
    "// Concrete prototype A\n",
    "public class ConcretePrototypeA : IPrototype\n",
    "{\n",
    "    private string propertyA;\n",
    "\n",
    "    public ConcretePrototypeA(string propertyA)\n",
    "    {\n",
    "        this.propertyA = propertyA;\n",
    "    }\n",
    "\n",
    "    public IPrototype Clone()\n",
    "    {\n",
    "        return new ConcretePrototypeA(propertyA);\n",
    "    }\n",
    "\n",
    "    public void Display()\n",
    "    {\n",
    "        Console.WriteLine($\"Property A: {propertyA}\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Concrete prototype B\n",
    "public class ConcretePrototypeB : IPrototype\n",
    "{\n",
    "    private int propertyB;\n",
    "\n",
    "    public ConcretePrototypeB(int propertyB)\n",
    "    {\n",
    "        this.propertyB = propertyB;\n",
    "    }\n",
    "\n",
    "    public IPrototype Clone()\n",
    "    {\n",
    "        return new ConcretePrototypeB(propertyB);\n",
    "    }\n",
    "\n",
    "    public void Display()\n",
    "    {\n",
    "        Console.WriteLine($\"Property B: {propertyB}\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Client\n",
    "public class Client\n",
    "{\n",
    "    public void Code()\n",
    "    {\n",
    "        // Create prototypes\n",
    "        IPrototype prototypeA = new ConcretePrototypeA(\"Value A\");\n",
    "        IPrototype prototypeB = new ConcretePrototypeB(42);\n",
    "\n",
    "        // Clone and modify prototypes\n",
    "        IPrototype clonedA = prototypeA.Clone();\n",
    "        clonedA.Display();\n",
    "\n",
    "        IPrototype clonedB = prototypeB.Clone();\n",
    "        clonedB.Display();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In this example:\n",
    "\n",
    "- The `IPrototype` interface declares the `Clone` method, which returns a cloned instance of the object.\n",
    "\n",
    "- The `ConcretePrototypeA` and `ConcretePrototypeB` classes implement the `IPrototype` interface and provide their specific implementations of the Clone method. They create new instances of themselves and copy their properties to the new objects.\n",
    "\n",
    "- The `Client` class demonstrates how the Prototype pattern is used. It creates instances of concrete prototypes (`ConcretePrototypeA` and `ConcretePrototypeB`), clones them using the `Clone` method, and then displays the properties of the cloned objects.\n",
    "\n",
    "> By utilizing the Prototype pattern, you can create new objects by cloning existing ones. This allows you to avoid the overhead of object creation and initialization, and it provides a convenient way to create variations of objects based on prototypes. The pattern promotes code reuse, simplifies object creation, and allows for dynamic object generation."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}