Software Dev/10 - Proxy.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Proxy\n",
    "\n",
    "## General idea\n",
    "The Proxy pattern is a structural design pattern that provides a surrogate or placeholder for another object. It allows you to control access to the real object and add additional functionality without changing the existing code. The Proxy pattern can be used to add a level of indirection between the client and the real object, providing a way to manage object creation, access permissions, resource usage, and other aspects.\n",
    "\n",
    "## Benefits\n",
    "- The Proxy pattern provides several benefits:\n",
    "\n",
    "- Remote Object Access: The Proxy pattern allows you to create a local representative for a remote object. The Proxy handles the communication with the remote object, making it transparent for the client. This can be useful when dealing with distributed systems or remote services.\n",
    "\n",
    "- Controlled Access: The Proxy pattern enables you to control access to the real object. The Proxy can implement additional checks, such as authentication, authorization, or rate limiting, before allowing the client to invoke methods on the real object. This helps in enforcing security and access control policies.\n",
    "\n",
    "- Deferred Object Creation: The Proxy pattern allows you to defer the creation of the real object until it is actually needed. This can be useful when the creation of the real object is expensive or requires significant resources. The Proxy can create the real object on-demand, improving performance and resource utilization.\n",
    "\n",
    "- Caching and Optimization: The Proxy pattern can be used to implement caching mechanisms. The Proxy can intercept requests and check if the result is already cached. If so, it can return the cached result directly, avoiding unnecessary computations or expensive operations. This can improve performance and reduce the load on the real object.\n",
    "\n",
    "- Simplified Client Code: The Proxy pattern abstracts away the complexities of accessing the real object. The client interacts with the Proxy using the same interface as the RealSubject, which provides a simplified and consistent interface for the client code.\n",
    "\n",
    "- Separation of Concerns: The Proxy pattern helps in separating the cross-cutting concerns from the core business logic. The Proxy can handle tasks like logging, auditing, or monitoring without modifying the RealSubject. This promotes code modularity and maintainability.\n",
    "\n",
    "> The Proxy pattern is commonly used in scenarios where you need to control access to an object or provide additional functionality without modifying the existing code. It helps in managing resources efficiently, simplifying client code, and adding cross-cutting concerns to the object interactions.\n",
    "\n",
    "## How it works\n",
    "- Subject: It defines the interface or abstract class that both the RealSubject and Proxy classes implement. This interface declares the methods that the client can invoke on the RealSubject.\n",
    "\n",
    "- RealSubject: It represents the real object that the Proxy stands in for. It provides the actual implementation of the operations defined in the Subject interface.\n",
    "\n",
    "- Proxy: It acts as a surrogate for the RealSubject and controls access to it. The Proxy implements the same interface as the RealSubject and maintains a reference to it. The Proxy intercepts client requests and may perform additional tasks before or after delegating the request to the RealSubject.\n",
    "\n",
    "- Client: It interacts with the Proxy object to perform operations on the RealSubject. The client is unaware of whether it is using the Proxy or the RealSubject since they both implement the same interface."
   ]
  },
  {
   "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 proxy pattern in C#\n",
    "\n",
    "// Subject interface\n",
    "public interface ISubject\n",
    "{\n",
    "    void Request();\n",
    "}\n",
    "\n",
    "// RealSubject\n",
    "public class RealSubject : ISubject\n",
    "{\n",
    "    public void Request()\n",
    "    {\n",
    "        Console.WriteLine(\"RealSubject handles the request.\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Proxy\n",
    "public class Proxy : ISubject\n",
    "{\n",
    "    private RealSubject realSubject;\n",
    "\n",
    "    public void Request()\n",
    "    {\n",
    "        // Lazy initialization: create the RealSubject on first request\n",
    "        if (realSubject == null)\n",
    "        {\n",
    "            realSubject = new RealSubject();\n",
    "        }\n",
    "\n",
    "        // Perform additional tasks before delegating to the RealSubject\n",
    "        Console.WriteLine(\"Proxy performs additional tasks before calling the RealSubject.\");\n",
    "\n",
    "        // Delegate the request to the RealSubject\n",
    "        realSubject.Request();\n",
    "\n",
    "        // Perform additional tasks after delegating to the RealSubject\n",
    "        Console.WriteLine(\"Proxy performs additional tasks after calling the RealSubject.\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Client\n",
    "public class Client\n",
    "{\n",
    "    public void Code()\n",
    "    {\n",
    "        // Create a Proxy object\n",
    "        Proxy proxy = new Proxy();\n",
    "\n",
    "        // Perform the request through the Proxy\n",
    "        proxy.Request();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In this example:\n",
    "\n",
    "- The `ISubject` interface defines the common interface for both the `RealSubject` and `Proxy` classes. It declares the `Request()` method that the client can invoke.\n",
    "\n",
    "- The `RealSubject` class represents the real object that the Proxy stands in for. It provides the actual implementation of the `Request()` method.\n",
    "\n",
    "- The `Proxy` class acts as a surrogate for the `RealSubject` and implements the `ISubject` interface. It maintains a reference to the `RealSubject` object and intercepts requests from the client. The Proxy performs additional tasks before and after delegating the request to the `RealSubject`.\n",
    "\n",
    "- The `Client` class demonstrates how the Proxy pattern is used. It creates an instance of the `Proxy` class and invokes the `Request()` method through the proxy.\n",
    "\n",
    "> By utilizing the Proxy pattern, you can control access to the real object (`RealSubject`), perform additional tasks before or after invoking methods on the real object, and provide a level of indirection between the client and the real object. This allows you to add functionality, such as caching, logging, security checks, or lazy initialization, without modifying the client code or the real object's implementation."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}