{"title":"Proxy Design Pattern","description":null,"content":"\n\n\n\n\n> **DEFINITION**\n>\n> The **Proxy Design Pattern** is a **structural pattern** that provides a **placeholder or surrogate** for another object, allowing you to **control access** to it.\n\n\nIn real-world systems, the objects you interact with are often resource-heavy, remote, or sensitive. Think of database connections, third-party APIs, file systems, or large in-memory datasets. Direct access to these objects is not always ideal.\n\nA proxy helps when you want to:\n\n- Delay creation or loading until it’s actually needed (lazy access).\n- Restrict or control access (authentication, authorization, rate limiting).\n- Add cross-cutting behavior like logging, caching, retries, or monitoring without changing the original class.\n\nThe proxy sits between the client and the real object, intercepting calls and deciding whether to forward them as-is, block them, or wrap them with extra behavior.\n\nLet’s walk through a real-world example and see how we can apply the Proxy Pattern to build safer, smarter, and more controlled interactions with expensive or sensitive resources.\n\n---\n\n# 1. The Problem: Eager Loading\n\nImagine you're building an **image gallery application**. Users scroll through a list of thumbnails, and when they click on one, the full high-resolution image is displayed.\n\nThe straightforward approach creates all images upfront. Here is what the code looks like without any proxy:\n\n\n```java\ninterface Image {\n void display();\n String getFileName();\n}\n\nclass HighResolutionImage implements Image {\n private String fileName;\n private byte[] imageData;\n\n public HighResolutionImage(String fileName) {\n this.fileName = fileName;\n loadImageFromDisk();\n }\n\n private void loadImageFromDisk() {\n System.out.println(\"Loading image: \" + fileName + \" from disk (Expensive Operation)...\");\n try {\n Thread.sleep(200);\n this.imageData = new byte[10 * 1024 * 1024];\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n System.out.println(\"Image \" + fileName + \" loaded successfully.\");\n }\n\n @Override\n public void display() {\n System.out.println(\"Displaying image: \" + fileName);\n }\n\n @Override\n public String getFileName() {\n return fileName;\n }\n}\n\npublic class ImageGalleryAppV1 {\n public static void main(String[] args) {\n System.out.println(\"Application Started. Initializing images for gallery...\");\n\n Image image1 = new HighResolutionImage(\"photo1.jpg\");\n Image image2 = new HighResolutionImage(\"photo2.png\");\n Image image3 = new HighResolutionImage(\"photo3.gif\");\n\n System.out.println(\"\\nGallery initialized. User might view an image now.\");\n\n System.out.println(\"User requests to display \" + image1.getFileName());\n image1.display();\n\n System.out.println(\"\\nUser requests to display \" + image3.getFileName());\n image3.display();\n\n System.out.println(\"\\nApplication finished.\");\n }\n}\n```\n\n```python\nimport time\nfrom abc import ABC, abstractmethod\n\nclass Image(ABC):\n @abstractmethod\n def display(self):\n pass\n\n @abstractmethod\n def get_file_name(self) -> str:\n pass\n\nclass HighResolutionImage(Image):\n def __init__(self, file_name: str):\n self.file_name = file_name\n self.image_data = None\n self._load_image_from_disk()\n\n def _load_image_from_disk(self):\n print(f\"Loading image: {self.file_name} from disk (Expensive Operation)...\")\n time.sleep(0.2)\n self.image_data = bytearray(10 * 1024 * 1024)\n print(f\"Image {self.file_name} loaded successfully.\")\n\n def display(self):\n print(f\"Displaying image: {self.file_name}\")\n\n def get_file_name(self) -> str:\n return self.file_name\n\nif __name__ == \"__main__\":\n print(\"Application Started. Initializing images for gallery...\")\n\n image1 = HighResolutionImage(\"photo1.jpg\")\n image2 = HighResolutionImage(\"photo2.png\")\n image3 = HighResolutionImage(\"photo3.gif\")\n\n print(\"\\nGallery initialized. User might view an image now.\")\n\n print(f\"User requests to display {image1.get_file_name()}\")\n image1.display()\n\n print(f\"\\nUser requests to display {image3.get_file_name()}\")\n image3.display()\n\n print(\"\\nApplication finished.\")\n```\n\n```cpp\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass Image {\npublic:\n virtual void display() = 0;\n virtual string getFileName() = 0;\n virtual ~Image() {}\n};\n\nclass HighResolutionImage : public Image {\nprivate:\n string fileName;\n char* imageData;\n\n void loadImageFromDisk() {\n cout << \"Loading image: \" << fileName << \" from disk (Expensive Operation)...\" << endl;\n this_thread::sleep_for(chrono::milliseconds(200));\n imageData = new char[10 * 1024 * 1024];\n cout << \"Image \" << fileName << \" loaded successfully.\" << endl;\n }\n\npublic:\n HighResolutionImage(string fileName) : fileName(fileName), imageData(nullptr) {\n loadImageFromDisk();\n }\n\n ~HighResolutionImage() {\n delete[] imageData;\n }\n\n void display() override {\n cout << \"Displaying image: \" << fileName << endl;\n }\n\n string getFileName() override {\n return fileName;\n }\n};\n\nint main() {\n cout << \"Application Started. Initializing images for gallery...\" << endl;\n\n Image* image1 = new HighResolutionImage(\"photo1.jpg\");\n Image* image2 = new HighResolutionImage(\"photo2.png\");\n Image* image3 = new HighResolutionImage(\"photo3.gif\");\n\n cout << \"\\nGallery initialized. User might view an image now.\" << endl;\n\n cout << \"User requests to display \" << image1->getFileName() << endl;\n image1->display();\n\n cout << \"\\nUser requests to display \" << image3->getFileName() << endl;\n image3->display();\n\n cout << \"\\nApplication finished.\" << endl;\n\n delete image1;\n delete image2;\n delete image3;\n return 0;\n}\n```\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\ntype Image interface {\n\tdisplay()\n\tgetFileName() string\n}\n\ntype HighResolutionImage struct {\n\tfileName string\n\timageData []byte\n}\n\nfunc NewHighResolutionImage(fileName string) *HighResolutionImage {\n\th := &HighResolutionImage{fileName: fileName}\n\th.loadImageFromDisk()\n\treturn h\n}\n\nfunc (h *HighResolutionImage) loadImageFromDisk() {\n\tfmt.Println(\"Loading image: \" + h.fileName + \" from disk (Expensive Operation)...\")\n\ttime.Sleep(200 * time.Millisecond)\n\th.imageData = make([]byte, 10*1024*1024)\n\tfmt.Println(\"Image \" + h.fileName + \" loaded successfully.\")\n}\n\nfunc (h *HighResolutionImage) display() {\n\tfmt.Println(\"Displaying image: \" + h.fileName)\n}\n\nfunc (h *HighResolutionImage) getFileName() string {\n\treturn h.fileName\n}\n\nfunc main() {\n\tfmt.Println(\"Application Started. Initializing images for gallery...\")\n\n\tvar image1 Image = NewHighResolutionImage(\"photo1.jpg\")\n\tvar image2 Image = NewHighResolutionImage(\"photo2.png\")\n\tvar image3 Image = NewHighResolutionImage(\"photo3.gif\")\n\n\t_ = image2\n\n\tfmt.Println(\"\\nGallery initialized. User might view an image now.\")\n\n\tfmt.Println(\"User requests to display \" + image1.getFileName())\n\timage1.display()\n\n\tfmt.Println(\"\\nUser requests to display \" + image3.getFileName())\n\timage3.display()\n\n\tfmt.Println(\"\\nApplication finished.\")\n}\n```\n\n```csharp\nusing System;\nusing System.Threading;\n\ninterface IImage\n{\n void Display();\n string GetFileName();\n}\n\nclass HighResolutionImage : IImage\n{\n private string fileName;\n private byte[] imageData;\n\n public HighResolutionImage(string fileName)\n {\n this.fileName = fileName;\n LoadImageFromDisk();\n }\n\n private void LoadImageFromDisk()\n {\n Console.WriteLine($\"Loading image: {fileName} from disk (Expensive Operation)...\");\n Thread.Sleep(200);\n imageData = new byte[10 * 1024 * 1024];\n Console.WriteLine($\"Image {fileName} loaded successfully.\");\n }\n\n public void Display()\n {\n Console.WriteLine($\"Displaying image: {fileName}\");\n }\n\n public string GetFileName()\n {\n return fileName;\n }\n}\n\npublic class ImageGalleryAppV1\n{\n public static void Main()\n {\n Console.WriteLine(\"Application Started. Initializing images for gallery...\");\n\n IImage image1 = new HighResolutionImage(\"photo1.jpg\");\n IImage image2 = new HighResolutionImage(\"photo2.png\");\n IImage image3 = new HighResolutionImage(\"photo3.gif\");\n\n Console.WriteLine(\"\\nGallery initialized. User might view an image now.\");\n\n Console.WriteLine($\"User requests to display {image1.GetFileName()}\");\n image1.Display();\n\n Console.WriteLine($\"\\nUser requests to display {image3.GetFileName()}\");\n image3.Display();\n\n Console.WriteLine(\"\\nApplication finished.\");\n }\n}\n```\n\n```typescript\ninterface Image {\n display(): void;\n getFileName(): string;\n}\n\nclass HighResolutionImage implements Image {\n private fileName: string;\n private imageData: Uint8Array;\n\n constructor(fileName: string) {\n this.fileName = fileName;\n this.loadImageFromDisk();\n }\n\n private loadImageFromDisk(): void {\n console.log(\"Loading image: \" + this.fileName + \" from disk (Expensive Operation)...\");\n const start = Date.now();\n while (Date.now() - start < 200) {}\n this.imageData = new Uint8Array(10 * 1024 * 1024);\n console.log(\"Image \" + this.fileName + \" loaded successfully.\");\n }\n\n display(): void {\n console.log(\"Displaying image: \" + this.fileName);\n }\n\n getFileName(): string {\n return this.fileName;\n }\n}\n\nconsole.log(\"Application Started. Initializing images for gallery...\");\n\nconst image1: Image = new HighResolutionImage(\"photo1.jpg\");\nconst image2: Image = new HighResolutionImage(\"photo2.png\");\nconst image3: Image = new HighResolutionImage(\"photo3.gif\");\n\nconsole.log(\"\\nGallery initialized. User might view an image now.\");\n\nconsole.log(\"User requests to display \" + image1.getFileName());\nimage1.display();\n\nconsole.log(\"\\nUser requests to display \" + image3.getFileName());\nimage3.display();\n\nconsole.log(\"\\nApplication finished.\");\n```\n\n\nEvery image gets loaded during construction. Here is the sequence of what happens when the gallery starts:\n\n\n```mermaid\nsequenceDiagram\n participant C as Client\n participant I1 as photo1.jpg\n participant I2 as photo2.png\n participant I3 as photo3.gif\n\n C->>I1: new HighResolutionImage(\"photo1.jpg\")\n Note over I1: Loads 10MB from disk (2s)\n I1-->>C: created\n\n C->>I2: new HighResolutionImage(\"photo2.png\")\n Note over I2: Loads 10MB from disk (2s)\n I2-->>C: created\n\n C->>I3: new HighResolutionImage(\"photo3.gif\")\n Note over I3: Loads 10MB from disk (2s)\n I3-->>C: created\n\n Note over C: 6 seconds later, 30MB used.
User only views 2 images.\n\n C->>I1: display()\n C->>I3: display()\n Note over I2: photo2.png was loaded
but never displayed\n```\n\n\n### What's Wrong With This Approach?\n\n#### 1. Resource-Intensive Initialization\n\nEvery `HighResolutionImage` loads its image data at the time of construction, even if the user never views the image. This leads to slow application startup, unnecessary memory consumption, and wasted I/O bandwidth. If your gallery displays dozens or hundreds of thumbnails, this approach quickly becomes a bottleneck.\n\n#### 2. No Control Over Access\n\nWhat if you want to log every time an image is actually displayed? Add permission checks before loading a sensitive image? Cache previously loaded images for reuse? \n\nRight now, you would have to modify the `HighResolutionImage` class directly, mixing responsibilities and breaking the Single Responsibility Principle.\n\n#### 3. Violates Single Responsibility Principle\n\nThe `HighResolutionImage` class does two things: it manages image data and it controls when that data is loaded. These are separate concerns. Loading policy (eager vs lazy, cached vs fresh, permitted vs denied) should not be baked into the data class itself.\n\n### What We Really Need\n\nWe need a solution that allows us to:\n\n- **Defer the expensive loading** of image data until it's actually needed.\n- **Add extra behaviors** like logging, access control, or caching **without changing** the existing `HighResolutionImage` class.\n- Maintain the same interface so that the client code doesn’t need to change.\n\nThis is where the **Proxy Design Pattern** comes into play.\n\n---\n\n# 2. What is the Proxy Pattern\n\nThe Proxy pattern is a structural pattern that provides a surrogate or placeholder for another object to control access to it. Instead of the client interacting directly with the real object, it interacts with a proxy that implements the same interface. The proxy decides when and how to forward requests to the real object.\n\nTwo characteristics define the pattern:\n\n1. **Same interface preservation:** The proxy implements the same interface as the real object. The client cannot tell whether it is talking to the real object or a stand-in.\n2. **Controlled access:** The proxy intercepts requests and adds behavior before, after, or instead of forwarding them. This might mean deferring creation, checking permissions, logging calls, or caching results.\n\n---\n\n## Class Diagram\n\n\n\n\n\nProxy has four participants.\n\n#### Subject (e.g., `Image`)\n\nThe common interface that both the real object and the proxy implement.\n\nIn our image gallery example, `Image` is the Subject. It declares `display()` and `getFileName()` methods that every participant implements.\n\n#### RealSubject (e.g., `HighResolutionImage`)\n\nThe actual object that performs the real, expensive work.\n\nIn our example, `HighResolutionImage` loads a 10MB image from disk during construction. It is the object we want to defer creating until absolutely necessary.\n\n#### Proxy (e.g., `ImageProxy`)\n\nA lightweight stand-in that implements the Subject interface and controls access to the RealSubject.\n\nIn our example, `ImageProxy` stores the filename but does not create a `HighResolutionImage` until `display()` is called. It can answer `getFileName()` without loading anything.\n\n#### Client (e.g., `ImageGalleryApp`)\n\nThe consumer that works with objects through the Subject interface.\n\nIn our example, the gallery app creates `Image` references and calls `display()` on whichever images the user clicks. It does not know or care whether those references point to proxies or real images.\n\n\n> **Types of Proxies**\n>\n> Depending on the use case, the Proxy may take different forms:\n>\n> - **Virtual Proxy: **Defers creation of the real object until it’s actually needed (lazy loading).\n> - **Protection Proxy: **Performs permission checks before allowing access to certain operations.\n> - **Remote Proxy: **Handles communication between local and remote objects over a network.\n> - **Caching Proxy: **Caches expensive results and avoids repeated calls to the real subject.\n> - **Smart Proxy: **Adds logging, reference counting, or monitoring before/after method calls.\n\n\n---\n\n# 3. How It Works\n\nHere is the Proxy workflow for our image gallery, step by step:\n\n\n```mermaid\nsequenceDiagram\n participant C as Client\n participant P as ImageProxy\n participant R as HighResolutionImage\n\n C->>P: getFileName()\n P-->>C: \"photo1.jpg\" (no loading)\n\n C->>P: display()\n Note over P: realImage is null, create it\n P->>R: new HighResolutionImage(\"photo1.jpg\")\n Note over R: Loads 10MB from disk\n R-->>P: created\n P->>R: display()\n R-->>P: \"Displaying photo1.jpg\"\n P-->>C: done\n\n C->>P: display()\n Note over P: realImage already exists\n P->>R: display()\n R-->>P: \"Displaying photo1.jpg\"\n P-->>C: done\n```\n\n\n#### **Step 1: Create the proxy**\n\nThe client creates an `ImageProxy` with the filename \"photo1.jpg\". The proxy stores the filename but does not load the image. Construction is instant and uses almost no memory.\n\n#### **Step 2: No loading happens**\n\nThe real `HighResolutionImage` does not exist yet. No disk I/O, no memory allocation. The proxy is a lightweight placeholder.\n\n#### **Step 3: Call a cheap operation**\n\nThe client calls `getFileName()` on the proxy. The proxy returns the stored filename directly, without creating the real image. Some operations do not need the real object at all.\n\n#### **Step 4: Call an expensive operation**\n\nThe client calls `display()`. The proxy checks if the real image has been created. It has not, so the proxy creates a `HighResolutionImage`, which loads the file from disk and allocates memory.\n\n#### **Step 5: Delegate to the real object**\n\nAfter creating the real image, the proxy calls `display()` on it. The real image renders itself.\n\n#### **Step 6: Subsequent calls skip creation**\n\nThe client calls `display()` again. The proxy sees that the real image already exists and delegates directly, with no loading delay.\n\n---\n\n# 4. Implementing Proxy\n\nNow let's refactor our image gallery to use the Proxy pattern. Instead of eagerly loading every `HighResolutionImage`, we will use a proxy that wraps it and defers loading until the image is actually needed.\n\n\n```mermaid\nclassDiagram\n class Image {\n <>\n +display()\n +getFileName() String\n }\n\n class HighResolutionImage {\n -fileName: String\n -imageData: byte[]\n +display()\n +getFileName() String\n }\n\n class ImageProxy {\n -fileName: String\n -realImage: HighResolutionImage\n +display()\n +getFileName() String\n }\n\n Image <|.. HighResolutionImage\n Image <|.. ImageProxy\n ImageProxy --> HighResolutionImage : creates lazily\n\n style Image fill:#69db7c,stroke:#000,color:#000\n style HighResolutionImage fill:#00ceff,stroke:#000,color:#000\n style ImageProxy fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### 1. Create the Proxy Class\n\nThe `ImageProxy` implements the same `Image` interface as `HighResolutionImage`, so the client can use it interchangeably. Internally, it stores the filename and only creates the real image when `display()` is called.\n\n\n```java\nclass ImageProxy implements Image {\n private String fileName;\n private HighResolutionImage realImage;\n\n public ImageProxy(String fileName) {\n this.fileName = fileName;\n System.out.println(\"ImageProxy: Created for \" + fileName + \". Real image not loaded yet.\");\n }\n\n @Override\n public String getFileName() {\n return fileName;\n }\n\n @Override\n public void display() {\n if (realImage == null) {\n System.out.println(\"ImageProxy: display() requested for \" + fileName + \". Loading high-resolution image...\");\n realImage = new HighResolutionImage(fileName);\n } else {\n System.out.println(\"ImageProxy: Using cached high-resolution image for \" + fileName);\n }\n realImage.display();\n }\n}\n```\n\n```python\nclass ImageProxy(Image):\n def __init__(self, file_name: str):\n self.file_name = file_name\n self.real_image = None\n print(f\"ImageProxy: Created for {file_name}. Real image not loaded yet.\")\n\n def get_file_name(self) -> str:\n return self.file_name\n\n def display(self):\n if self.real_image is None:\n print(f\"ImageProxy: display() requested for {self.file_name}. Loading high-resolution image...\")\n self.real_image = HighResolutionImage(self.file_name)\n else:\n print(f\"ImageProxy: Using cached high-resolution image for {self.file_name}\")\n self.real_image.display()\n```\n\n```cpp\nclass ImageProxy : public Image {\nprivate:\n string fileName;\n HighResolutionImage* realImage;\n\npublic:\n ImageProxy(string fileName) : fileName(fileName), realImage(nullptr) {\n cout << \"ImageProxy: Created for \" << fileName << \". Real image not loaded yet.\" << endl;\n }\n\n ~ImageProxy() {\n delete realImage;\n }\n\n string getFileName() override {\n return fileName;\n }\n\n void display() override {\n if (realImage == nullptr) {\n cout << \"ImageProxy: display() requested for \" << fileName << \". Loading high-resolution image...\" << endl;\n realImage = new HighResolutionImage(fileName);\n } else {\n cout << \"ImageProxy: Using cached high-resolution image for \" << fileName << endl;\n }\n realImage->display();\n }\n};\n```\n\n```go\ntype ImageProxy struct {\n\tfileName string\n\trealImage *HighResolutionImage\n}\n\nfunc NewImageProxy(fileName string) *ImageProxy {\n\tfmt.Println(\"ImageProxy: Created for \" + fileName + \". Real image not loaded yet.\")\n\treturn &ImageProxy{fileName: fileName}\n}\n\nfunc (p *ImageProxy) GetFileName() string {\n\treturn p.fileName\n}\n\nfunc (p *ImageProxy) Display() {\n\tif p.realImage == nil {\n\t\tfmt.Println(\"ImageProxy: display() requested for \" + p.fileName + \". Loading high-resolution image...\")\n\t\tp.realImage = NewHighResolutionImage(p.fileName)\n\t} else {\n\t\tfmt.Println(\"ImageProxy: Using cached high-resolution image for \" + p.fileName)\n\t}\n\tp.realImage.Display()\n}\n```\n\n```csharp\nclass ImageProxy : IImage\n{\n private string fileName;\n private HighResolutionImage realImage;\n\n public ImageProxy(string fileName)\n {\n this.fileName = fileName;\n Console.WriteLine($\"ImageProxy: Created for {fileName}. Real image not loaded yet.\");\n }\n\n public string GetFileName()\n {\n return fileName;\n }\n\n public void Display()\n {\n if (realImage == null)\n {\n Console.WriteLine($\"ImageProxy: Display() requested for {fileName}. Loading high-resolution image...\");\n realImage = new HighResolutionImage(fileName);\n }\n else\n {\n Console.WriteLine($\"ImageProxy: Using cached high-resolution image for {fileName}\");\n }\n realImage.Display();\n }\n}\n```\n\n```typescript\nclass ImageProxy implements Image {\n private fileName: string;\n private realImage: HighResolutionImage | null = null;\n\n constructor(fileName: string) {\n this.fileName = fileName;\n console.log(\"ImageProxy: Created for \" + fileName + \". Real image not loaded yet.\");\n }\n\n getFileName(): string {\n return this.fileName;\n }\n\n display(): void {\n if (this.realImage === null) {\n console.log(\"ImageProxy: display() requested for \" + this.fileName + \". Loading high-resolution image...\");\n this.realImage = new HighResolutionImage(this.fileName);\n } else {\n console.log(\"ImageProxy: Using cached high-resolution image for \" + this.fileName);\n }\n this.realImage.display();\n }\n}\n```\n\n\n### 2. Using the Proxy from the Client\n\nFrom the client's perspective, nothing changes. It still interacts with `Image` references. But now, instead of dealing with heavyweight objects upfront, it gets lightweight proxies that only load the real object on demand.\n\n\n```java\npublic class ImageGalleryAppV2 {\n public static void main(String[] args) {\n System.out.println(\"Application Started. Initializing image proxies for gallery...\");\n\n Image image1 = new ImageProxy(\"photo1.jpg\");\n Image image2 = new ImageProxy(\"photo2.png\");\n Image image3 = new ImageProxy(\"photo3.gif\");\n\n System.out.println(\"\\nGallery initialized. No images actually loaded yet.\");\n System.out.println(\"Image 1 Filename: \" + image1.getFileName());\n\n System.out.println(\"\\nUser requests to display \" + image1.getFileName());\n image1.display();\n\n System.out.println(\"\\nUser requests to display \" + image1.getFileName() + \" again.\");\n image1.display();\n\n System.out.println(\"\\nUser requests to display \" + image3.getFileName());\n image3.display();\n\n System.out.println(\"\\nApplication finished. Note: photo2.png was never loaded.\");\n }\n}\n```\n\n```python\nif __name__ == \"__main__\":\n print(\"Application Started. Initializing image proxies for gallery...\")\n\n image1 = ImageProxy(\"photo1.jpg\")\n image2 = ImageProxy(\"photo2.png\")\n image3 = ImageProxy(\"photo3.gif\")\n\n print(\"\\nGallery initialized. No images actually loaded yet.\")\n print(f\"Image 1 Filename: {image1.get_file_name()}\")\n\n print(f\"\\nUser requests to display {image1.get_file_name()}\")\n image1.display()\n\n print(f\"\\nUser requests to display {image1.get_file_name()} again.\")\n image1.display()\n\n print(f\"\\nUser requests to display {image3.get_file_name()}\")\n image3.display()\n\n print(\"\\nApplication finished. Note: photo2.png was never loaded.\")\n```\n\n```cpp\nint main() {\n cout << \"Application Started. Initializing image proxies for gallery...\" << endl;\n\n Image* image1 = new ImageProxy(\"photo1.jpg\");\n Image* image2 = new ImageProxy(\"photo2.png\");\n Image* image3 = new ImageProxy(\"photo3.gif\");\n\n cout << \"\\nGallery initialized. No images actually loaded yet.\" << endl;\n cout << \"Image 1 Filename: \" << image1->getFileName() << endl;\n\n cout << \"\\nUser requests to display \" << image1->getFileName() << endl;\n image1->display();\n\n cout << \"\\nUser requests to display \" << image1->getFileName() << \" again.\" << endl;\n image1->display();\n\n cout << \"\\nUser requests to display \" << image3->getFileName() << endl;\n image3->display();\n\n cout << \"\\nApplication finished. Note: photo2.png was never loaded.\" << endl;\n\n delete image1;\n delete image2;\n delete image3;\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"Application Started. Initializing image proxies for gallery...\")\n\n\timage1 := NewImageProxy(\"photo1.jpg\")\n\timage2 := NewImageProxy(\"photo2.png\")\n\timage3 := NewImageProxy(\"photo3.gif\")\n\n\tfmt.Println(\"\\nGallery initialized. No images actually loaded yet.\")\n\tfmt.Println(\"Image 1 Filename: \" + image1.GetFileName())\n\n\tfmt.Println(\"\\nUser requests to display \" + image1.GetFileName())\n\timage1.Display()\n\n\tfmt.Println(\"\\nUser requests to display \" + image1.GetFileName() + \" again.\")\n\timage1.Display()\n\n\tfmt.Println(\"\\nUser requests to display \" + image3.GetFileName())\n\timage3.Display()\n\n\tfmt.Println(\"\\nApplication finished. Note: photo2.png was never loaded.\")\n\t_ = image2\n}\n```\n\n```csharp\npublic class ImageGalleryAppV2\n{\n public static void Main()\n {\n Console.WriteLine(\"Application Started. Initializing image proxies for gallery...\");\n\n IImage image1 = new ImageProxy(\"photo1.jpg\");\n IImage image2 = new ImageProxy(\"photo2.png\");\n IImage image3 = new ImageProxy(\"photo3.gif\");\n\n Console.WriteLine(\"\\nGallery initialized. No images actually loaded yet.\");\n Console.WriteLine($\"Image 1 Filename: {image1.GetFileName()}\");\n\n Console.WriteLine($\"\\nUser requests to display {image1.GetFileName()}\");\n image1.Display();\n\n Console.WriteLine($\"\\nUser requests to display {image1.GetFileName()} again.\");\n image1.Display();\n\n Console.WriteLine($\"\\nUser requests to display {image3.GetFileName()}\");\n image3.Display();\n\n Console.WriteLine(\"\\nApplication finished. Note: photo2.png was never loaded.\");\n }\n}\n```\n\n```typescript\nconsole.log(\"Application Started. Initializing image proxies for gallery...\");\n\nconst image1: Image = new ImageProxy(\"photo1.jpg\");\nconst image2: Image = new ImageProxy(\"photo2.png\");\nconst image3: Image = new ImageProxy(\"photo3.gif\");\n\nconsole.log(\"\\nGallery initialized. No images actually loaded yet.\");\nconsole.log(\"Image 1 Filename: \" + image1.getFileName());\n\nconsole.log(\"\\nUser requests to display \" + image1.getFileName());\nimage1.display();\n\nconsole.log(\"\\nUser requests to display \" + image1.getFileName() + \" again.\");\nimage1.display();\n\nconsole.log(\"\\nUser requests to display \" + image3.getFileName());\nimage3.display();\n\nconsole.log(\"\\nApplication finished. Note: photo2.png was never loaded.\");\n```\n\n\n#### **Output:**\n\n\n```plaintext\nApplication Started. Initializing image proxies for gallery...\nImageProxy: Created for photo1.jpg. Real image not loaded yet.\nImageProxy: Created for photo2.png. Real image not loaded yet.\nImageProxy: Created for photo3.gif. Real image not loaded yet.\n\nGallery initialized. No images actually loaded yet.\nImage 1 Filename: photo1.jpg\n\nUser requests to display photo1.jpg\nImageProxy: display() requested for photo1.jpg. Loading high-resolution image...\nLoading image: photo1.jpg from disk (Expensive Operation)...\nImage photo1.jpg loaded successfully.\nDisplaying image: photo1.jpg\n\nUser requests to display photo1.jpg again.\nImageProxy: Using cached high-resolution image for photo1.jpg\nDisplaying image: photo1.jpg\n\nUser requests to display photo3.gif\nImageProxy: display() requested for photo3.gif. Loading high-resolution image...\nLoading image: photo3.gif from disk (Expensive Operation)...\nImage photo3.gif loaded successfully.\nDisplaying image: photo3.gif\n\nApplication finished. Note: photo2.png was never loaded.\n```\n\n\n### **What We Achieved:**\n\n- **Lazy loading:** Images are only loaded when the user actually views them, cutting startup time from 6 seconds to near-instant\n- **Memory savings:** photo2.png was never loaded, saving 10MB of memory\n- **Same interface:** The client code uses `Image` references throughout, unaware of the proxy\n- **No changes to the real object:** `HighResolutionImage` was not modified at all\n- **Cached access:** The second `display()` call on photo1.jpg reuses the already-loaded image with no delay\n\n---\n\n# 5. Extending the Design: Other Proxy Types\n\nOne of the most powerful aspects of the Proxy pattern is how easily it extends to support different concerns. The virtual proxy we just built defers creation. But the same structure supports access control, logging, caching, and more, all without modifying the real object or changing the client code significantly.\n\n### 1. Adding a Protection Proxy\n\nA protection proxy controls access based on authorization rules. For example, only users with an `ADMIN` role should be able to view confidential images.\n\nThe key design decision here is how to pass user context. You might be tempted to change the `display()` method signature to accept a user role, but that would break the `Image` interface contract. Instead, the user context is passed through the proxy's constructor. The proxy knows who the user is, and the interface stays clean.\n\n\n```java\nclass SecureImageProxy implements Image {\n private String fileName;\n private String userRole;\n private HighResolutionImage realImage;\n\n public SecureImageProxy(String fileName, String userRole) {\n this.fileName = fileName;\n this.userRole = userRole;\n }\n\n @Override\n public String getFileName() {\n return fileName;\n }\n\n @Override\n public void display() {\n if (!checkAccess()) {\n System.out.println(\"SecureImageProxy: ACCESS DENIED for \" + fileName + \" (role: \" + userRole + \")\");\n return;\n }\n if (realImage == null) {\n realImage = new HighResolutionImage(fileName);\n }\n realImage.display();\n }\n\n private boolean checkAccess() {\n System.out.println(\"SecureImageProxy: Checking access for role '\" + userRole + \"' on \" + fileName);\n return \"ADMIN\".equals(userRole) || !fileName.contains(\"secret\");\n }\n}\n```\n\n```python\nclass SecureImageProxy(Image):\n def __init__(self, file_name: str, user_role: str):\n self.file_name = file_name\n self.user_role = user_role\n self.real_image = None\n\n def get_file_name(self) -> str:\n return self.file_name\n\n def display(self):\n if not self._check_access():\n print(f\"SecureImageProxy: ACCESS DENIED for {self.file_name} (role: {self.user_role})\")\n return\n if self.real_image is None:\n self.real_image = HighResolutionImage(self.file_name)\n self.real_image.display()\n\n def _check_access(self) -> bool:\n print(f\"SecureImageProxy: Checking access for role '{self.user_role}' on {self.file_name}\")\n return self.user_role == \"ADMIN\" or \"secret\" not in self.file_name\n```\n\n```cpp\nclass SecureImageProxy : public Image {\nprivate:\n string fileName;\n string userRole;\n HighResolutionImage* realImage;\n\n bool checkAccess() {\n cout << \"SecureImageProxy: Checking access for role '\" << userRole << \"' on \" << fileName << endl;\n return userRole == \"ADMIN\" || fileName.find(\"secret\") == string::npos;\n }\n\npublic:\n SecureImageProxy(string fileName, string userRole)\n : fileName(fileName), userRole(userRole), realImage(nullptr) {}\n\n ~SecureImageProxy() { delete realImage; }\n\n string getFileName() override { return fileName; }\n\n void display() override {\n if (!checkAccess()) {\n cout << \"SecureImageProxy: ACCESS DENIED for \" << fileName << \" (role: \" << userRole << \")\" << endl;\n return;\n }\n if (realImage == nullptr) {\n realImage = new HighResolutionImage(fileName);\n }\n realImage->display();\n }\n};\n```\n\n```go\ntype SecureImageProxy struct {\n\tfileName string\n\tuserRole string\n\trealImage *HighResolutionImage\n}\n\nfunc NewSecureImageProxy(fileName, userRole string) *SecureImageProxy {\n\treturn &SecureImageProxy{fileName: fileName, userRole: userRole}\n}\n\nfunc (s *SecureImageProxy) GetFileName() string {\n\treturn s.fileName\n}\n\nfunc (s *SecureImageProxy) Display() {\n\tif !s.checkAccess() {\n\t\tfmt.Println(\"SecureImageProxy: ACCESS DENIED for \" + s.fileName + \" (role: \" + s.userRole + \")\")\n\t\treturn\n\t}\n\tif s.realImage == nil {\n\t\ts.realImage = NewHighResolutionImage(s.fileName)\n\t}\n\ts.realImage.Display()\n}\n\nfunc (s *SecureImageProxy) checkAccess() bool {\n\tfmt.Println(\"SecureImageProxy: Checking access for role '\" + s.userRole + \"' on \" + s.fileName)\n\treturn s.userRole == \"ADMIN\" || !strings.Contains(s.fileName, \"secret\")\n}\n```\n\n```csharp\nclass SecureImageProxy : IImage\n{\n private string fileName;\n private string userRole;\n private HighResolutionImage realImage;\n\n public SecureImageProxy(string fileName, string userRole)\n {\n this.fileName = fileName;\n this.userRole = userRole;\n }\n\n public string GetFileName() => fileName;\n\n public void Display()\n {\n if (!CheckAccess())\n {\n Console.WriteLine($\"SecureImageProxy: ACCESS DENIED for {fileName} (role: {userRole})\");\n return;\n }\n if (realImage == null)\n {\n realImage = new HighResolutionImage(fileName);\n }\n realImage.Display();\n }\n\n private bool CheckAccess()\n {\n Console.WriteLine($\"SecureImageProxy: Checking access for role '{userRole}' on {fileName}\");\n return userRole == \"ADMIN\" || !fileName.Contains(\"secret\");\n }\n}\n```\n\n```typescript\nclass SecureImageProxy implements Image {\n private fileName: string;\n private userRole: string;\n private realImage: HighResolutionImage | null = null;\n\n constructor(fileName: string, userRole: string) {\n this.fileName = fileName;\n this.userRole = userRole;\n }\n\n getFileName(): string {\n return this.fileName;\n }\n\n display(): void {\n if (!this.checkAccess()) {\n console.log(\"SecureImageProxy: ACCESS DENIED for \" + this.fileName + \" (role: \" + this.userRole + \")\");\n return;\n }\n if (this.realImage === null) {\n this.realImage = new HighResolutionImage(this.fileName);\n }\n this.realImage.display();\n }\n\n private checkAccess(): boolean {\n console.log(\"SecureImageProxy: Checking access for role '\" + this.userRole + \"' on \" + this.fileName);\n return this.userRole === \"ADMIN\" || !this.fileName.includes(\"secret\");\n }\n}\n```\n\n\nNotice that the `Image` interface is unchanged. The proxy constructor takes the user role as extra context, and `display()` checks access before creating or delegating to the real object. An admin can view anything. A regular user gets blocked from files containing \"secret\" in the name.\n\n### 2. Adding a Logging Proxy\n\nA logging proxy intercepts method calls and records them for auditing, debugging, or usage analytics. It wraps an existing `Image` and logs timestamps before and after each operation.\n\n\n```java\nclass LoggingImageProxy implements Image {\n private Image wrappedImage;\n\n public LoggingImageProxy(Image wrappedImage) {\n this.wrappedImage = wrappedImage;\n }\n\n @Override\n public String getFileName() {\n return wrappedImage.getFileName();\n }\n\n @Override\n public void display() {\n System.out.println(\"[LOG \" + new java.util.Date() + \"] display() called for \" + getFileName());\n wrappedImage.display();\n System.out.println(\"[LOG \" + new java.util.Date() + \"] display() completed for \" + getFileName());\n }\n}\n```\n\n```python\nfrom datetime import datetime\n\nclass LoggingImageProxy(Image):\n def __init__(self, wrapped_image: Image):\n self.wrapped_image = wrapped_image\n\n def get_file_name(self) -> str:\n return self.wrapped_image.get_file_name()\n\n def display(self):\n print(f\"[LOG {datetime.now()}] display() called for {self.get_file_name()}\")\n self.wrapped_image.display()\n print(f\"[LOG {datetime.now()}] display() completed for {self.get_file_name()}\")\n```\n\n```cpp\nclass LoggingImageProxy : public Image {\nprivate:\n Image* wrappedImage;\n\npublic:\n LoggingImageProxy(Image* wrappedImage) : wrappedImage(wrappedImage) {}\n\n string getFileName() override {\n return wrappedImage->getFileName();\n }\n\n void display() override {\n time_t now = time(0);\n cout << \"[LOG \" << ctime(&now) << \"] display() called for \" << getFileName() << endl;\n wrappedImage->display();\n now = time(0);\n cout << \"[LOG \" << ctime(&now) << \"] display() completed for \" << getFileName() << endl;\n }\n};\n```\n\n```go\ntype LoggingImageProxy struct {\n\twrappedImage Image\n}\n\nfunc NewLoggingImageProxy(wrappedImage Image) *LoggingImageProxy {\n\treturn &LoggingImageProxy{wrappedImage: wrappedImage}\n}\n\nfunc (p *LoggingImageProxy) GetFileName() string {\n\treturn p.wrappedImage.GetFileName()\n}\n\nfunc (p *LoggingImageProxy) Display() {\n\tfmt.Println(\"[LOG \" + time.Now().String() + \"] display() called for \" + p.GetFileName())\n\tp.wrappedImage.Display()\n\tfmt.Println(\"[LOG \" + time.Now().String() + \"] display() completed for \" + p.GetFileName())\n}\n```\n\n```csharp\nclass LoggingImageProxy : IImage\n{\n private IImage wrappedImage;\n\n public LoggingImageProxy(IImage wrappedImage)\n {\n this.wrappedImage = wrappedImage;\n }\n\n public string GetFileName() => wrappedImage.GetFileName();\n\n public void Display()\n {\n Console.WriteLine($\"[LOG {DateTime.Now}] Display() called for {GetFileName()}\");\n wrappedImage.Display();\n Console.WriteLine($\"[LOG {DateTime.Now}] Display() completed for {GetFileName()}\");\n }\n}\n```\n\n```typescript\nclass LoggingImageProxy implements Image {\n private wrappedImage: Image;\n\n constructor(wrappedImage: Image) {\n this.wrappedImage = wrappedImage;\n }\n\n getFileName(): string {\n return this.wrappedImage.getFileName();\n }\n\n display(): void {\n console.log(\"[LOG \" + new Date().toISOString() + \"] display() called for \" + this.getFileName());\n this.wrappedImage.display();\n console.log(\"[LOG \" + new Date().toISOString() + \"] display() completed for \" + this.getFileName());\n }\n}\n```\n\n\nNotice that the logging proxy wraps any `Image`, not just `HighResolutionImage`. You could stack it on top of the virtual proxy: `new LoggingImageProxy(new ImageProxy(\"photo1.jpg\"))`. The logging proxy logs the call, then delegates to the virtual proxy, which handles lazy loading. Each proxy handles one concern.\n\n---\n\n# 6. Practical Example: Database Query Caching Proxy\n\nTo show the Proxy pattern in a completely different domain, let's build a database query caching system. The interface defines a simple query operation. The real implementation simulates a slow database. The caching proxy stores results and returns cached values for repeated queries.\n\n\n```mermaid\nclassDiagram\n class DatabaseService {\n <>\n +query(sql: String) String\n }\n\n class RealDatabaseService {\n +query(sql: String) String\n }\n\n class CachingDatabaseProxy {\n -realService: RealDatabaseService\n -cache: Map~String, String~\n +query(sql: String) String\n +clearCache()\n }\n\n DatabaseService <|.. RealDatabaseService\n DatabaseService <|.. CachingDatabaseProxy\n CachingDatabaseProxy --> RealDatabaseService : delegates to\n\n style DatabaseService fill:#69db7c,stroke:#000,color:#000\n style RealDatabaseService fill:#00ceff,stroke:#000,color:#000\n style CachingDatabaseProxy fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### Implementation\n\n\n```java\nimport java.util.HashMap;\nimport java.util.Map;\n\ninterface DatabaseService {\n String query(String sql);\n}\n\nclass RealDatabaseService implements DatabaseService {\n @Override\n public String query(String sql) {\n System.out.println(\"RealDatabase: Executing query: \" + sql);\n try {\n Thread.sleep(100);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n return \"Result for [\" + sql + \"]\";\n }\n}\n\nclass CachingDatabaseProxy implements DatabaseService {\n private RealDatabaseService realService;\n private Map cache = new HashMap<>();\n\n public CachingDatabaseProxy() {\n this.realService = new RealDatabaseService();\n }\n\n @Override\n public String query(String sql) {\n if (cache.containsKey(sql)) {\n System.out.println(\"CachingProxy: Cache HIT for: \" + sql);\n return cache.get(sql);\n }\n System.out.println(\"CachingProxy: Cache MISS for: \" + sql);\n String result = realService.query(sql);\n cache.put(sql, result);\n return result;\n }\n\n public void clearCache() {\n System.out.println(\"CachingProxy: Cache cleared.\");\n cache.clear();\n }\n}\n\npublic class DatabaseCacheDemo {\n public static void main(String[] args) {\n CachingDatabaseProxy db = new CachingDatabaseProxy();\n\n System.out.println(\"--- First query (cache miss) ---\");\n System.out.println(db.query(\"SELECT * FROM users\"));\n\n System.out.println(\"\\n--- Same query again (cache hit) ---\");\n System.out.println(db.query(\"SELECT * FROM users\"));\n\n System.out.println(\"\\n--- Different query (cache miss) ---\");\n System.out.println(db.query(\"SELECT * FROM orders WHERE status = 'pending'\"));\n\n System.out.println(\"\\n--- Clear cache and retry ---\");\n db.clearCache();\n System.out.println(db.query(\"SELECT * FROM users\"));\n }\n}\n```\n\n```python\nimport time\nfrom abc import ABC, abstractmethod\n\nclass DatabaseService(ABC):\n @abstractmethod\n def query(self, sql: str) -> str:\n pass\n\nclass RealDatabaseService(DatabaseService):\n def query(self, sql: str) -> str:\n print(f\"RealDatabase: Executing query: {sql}\")\n time.sleep(0.1)\n return f\"Result for [{sql}]\"\n\nclass CachingDatabaseProxy(DatabaseService):\n def __init__(self):\n self.real_service = RealDatabaseService()\n self.cache: dict[str, str] = {}\n\n def query(self, sql: str) -> str:\n if sql in self.cache:\n print(f\"CachingProxy: Cache HIT for: {sql}\")\n return self.cache[sql]\n print(f\"CachingProxy: Cache MISS for: {sql}\")\n result = self.real_service.query(sql)\n self.cache[sql] = result\n return result\n\n def clear_cache(self):\n print(\"CachingProxy: Cache cleared.\")\n self.cache.clear()\n\nif __name__ == \"__main__\":\n db = CachingDatabaseProxy()\n\n print(\"--- First query (cache miss) ---\")\n print(db.query(\"SELECT * FROM users\"))\n\n print(\"\\n--- Same query again (cache hit) ---\")\n print(db.query(\"SELECT * FROM users\"))\n\n print(\"\\n--- Different query (cache miss) ---\")\n print(db.query(\"SELECT * FROM orders WHERE status = 'pending'\"))\n\n print(\"\\n--- Clear cache and retry ---\")\n db.clear_cache()\n print(db.query(\"SELECT * FROM users\"))\n```\n\n```cpp\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass DatabaseService {\npublic:\n virtual string query(const string& sql) = 0;\n virtual ~DatabaseService() {}\n};\n\nclass RealDatabaseService : public DatabaseService {\npublic:\n string query(const string& sql) override {\n cout << \"RealDatabase: Executing query: \" << sql << endl;\n this_thread::sleep_for(chrono::milliseconds(100));\n return \"Result for [\" + sql + \"]\";\n }\n};\n\nclass CachingDatabaseProxy : public DatabaseService {\nprivate:\n RealDatabaseService realService;\n unordered_map cache;\n\npublic:\n string query(const string& sql) override {\n auto it = cache.find(sql);\n if (it != cache.end()) {\n cout << \"CachingProxy: Cache HIT for: \" << sql << endl;\n return it->second;\n }\n cout << \"CachingProxy: Cache MISS for: \" << sql << endl;\n string result = realService.query(sql);\n cache[sql] = result;\n return result;\n }\n\n void clearCache() {\n cout << \"CachingProxy: Cache cleared.\" << endl;\n cache.clear();\n }\n};\n\nint main() {\n CachingDatabaseProxy db;\n\n cout << \"--- First query (cache miss) ---\" << endl;\n cout << db.query(\"SELECT * FROM users\") << endl;\n\n cout << \"\\n--- Same query again (cache hit) ---\" << endl;\n cout << db.query(\"SELECT * FROM users\") << endl;\n\n cout << \"\\n--- Different query (cache miss) ---\" << endl;\n cout << db.query(\"SELECT * FROM orders WHERE status = 'pending'\") << endl;\n\n cout << \"\\n--- Clear cache and retry ---\" << endl;\n db.clearCache();\n cout << db.query(\"SELECT * FROM users\") << endl;\n\n return 0;\n}\n```\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\ntype DatabaseService interface {\n\tquery(sql string) string\n}\n\ntype RealDatabaseService struct{}\n\nfunc (r *RealDatabaseService) query(sql string) string {\n\tfmt.Println(\"RealDatabase: Executing query: \" + sql)\n\ttime.Sleep(100 * time.Millisecond)\n\treturn \"Result for [\" + sql + \"]\"\n}\n\ntype CachingDatabaseProxy struct {\n\trealService *RealDatabaseService\n\tcache map[string]string\n}\n\nfunc NewCachingDatabaseProxy() *CachingDatabaseProxy {\n\treturn &CachingDatabaseProxy{\n\t\trealService: &RealDatabaseService{},\n\t\tcache: make(map[string]string),\n\t}\n}\n\nfunc (c *CachingDatabaseProxy) query(sql string) string {\n\tif result, ok := c.cache[sql]; ok {\n\t\tfmt.Println(\"CachingProxy: Cache HIT for: \" + sql)\n\t\treturn result\n\t}\n\tfmt.Println(\"CachingProxy: Cache MISS for: \" + sql)\n\tresult := c.realService.query(sql)\n\tc.cache[sql] = result\n\treturn result\n}\n\nfunc (c *CachingDatabaseProxy) clearCache() {\n\tfmt.Println(\"CachingProxy: Cache cleared.\")\n\tc.cache = make(map[string]string)\n}\n\nfunc main() {\n\tdb := NewCachingDatabaseProxy()\n\n\tfmt.Println(\"--- First query (cache miss) ---\")\n\tfmt.Println(db.query(\"SELECT * FROM users\"))\n\n\tfmt.Println(\"\\n--- Same query again (cache hit) ---\")\n\tfmt.Println(db.query(\"SELECT * FROM users\"))\n\n\tfmt.Println(\"\\n--- Different query (cache miss) ---\")\n\tfmt.Println(db.query(\"SELECT * FROM orders WHERE status = 'pending'\"))\n\n\tfmt.Println(\"\\n--- Clear cache and retry ---\")\n\tdb.clearCache()\n\tfmt.Println(db.query(\"SELECT * FROM users\"))\n}\n```\n\n```csharp\nusing System;\nusing System.Collections.Generic;\nusing System.Threading;\n\ninterface IDatabaseService\n{\n string Query(string sql);\n}\n\nclass RealDatabaseService : IDatabaseService\n{\n public string Query(string sql)\n {\n Console.WriteLine(\"RealDatabase: Executing query: \" + sql);\n Thread.Sleep(100);\n return \"Result for [\" + sql + \"]\";\n }\n}\n\nclass CachingDatabaseProxy : IDatabaseService\n{\n private RealDatabaseService realService = new RealDatabaseService();\n private Dictionary cache = new Dictionary();\n\n public string Query(string sql)\n {\n if (cache.ContainsKey(sql))\n {\n Console.WriteLine(\"CachingProxy: Cache HIT for: \" + sql);\n return cache[sql];\n }\n\n Console.WriteLine(\"CachingProxy: Cache MISS for: \" + sql);\n string result = realService.Query(sql);\n cache[sql] = result;\n return result;\n }\n\n public void ClearCache()\n {\n Console.WriteLine(\"CachingProxy: Cache cleared.\");\n cache.Clear();\n }\n}\n\npublic class Program\n{\n public static void Main()\n {\n var db = new CachingDatabaseProxy();\n\n Console.WriteLine(\"--- First query (cache miss) ---\");\n Console.WriteLine(db.Query(\"SELECT * FROM users\"));\n\n Console.WriteLine(\"\\n--- Same query again (cache hit) ---\");\n Console.WriteLine(db.Query(\"SELECT * FROM users\"));\n\n Console.WriteLine(\"\\n--- Different query (cache miss) ---\");\n Console.WriteLine(db.Query(\"SELECT * FROM orders WHERE status = 'pending'\"));\n\n Console.WriteLine(\"\\n--- Clear cache and retry ---\");\n db.ClearCache();\n Console.WriteLine(db.Query(\"SELECT * FROM users\"));\n }\n}\n```\n\n```typescript\ninterface DatabaseService {\n query(sql: string): string;\n}\n\nclass RealDatabaseService implements DatabaseService {\n query(sql: string): string {\n console.log(\"RealDatabase: Executing query: \" + sql);\n const start = Date.now();\n while (Date.now() - start < 100) {}\n return \"Result for [\" + sql + \"]\";\n }\n}\n\nclass CachingDatabaseProxy implements DatabaseService {\n private realService = new RealDatabaseService();\n private cache: Map = new Map();\n\n query(sql: string): string {\n const cached = this.cache.get(sql);\n if (cached !== undefined) {\n console.log(\"CachingProxy: Cache HIT for: \" + sql);\n return cached;\n }\n console.log(\"CachingProxy: Cache MISS for: \" + sql);\n const result = this.realService.query(sql);\n this.cache.set(sql, result);\n return result;\n }\n\n clearCache(): void {\n console.log(\"CachingProxy: Cache cleared.\");\n this.cache.clear();\n }\n}\n\nconst db = new CachingDatabaseProxy();\n\nconsole.log(\"--- First query (cache miss) ---\");\nconsole.log(db.query(\"SELECT * FROM users\"));\n\nconsole.log(\"\\n--- Same query again (cache hit) ---\");\nconsole.log(db.query(\"SELECT * FROM users\"));\n\nconsole.log(\"\\n--- Different query (cache miss) ---\");\nconsole.log(db.query(\"SELECT * FROM orders WHERE status = 'pending'\"));\n\nconsole.log(\"\\n--- Clear cache and retry ---\");\ndb.clearCache();\nconsole.log(db.query(\"SELECT * FROM users\"));\n```\n\n\nThe first query takes a full 100 milliseconds (simulated database latency). The identical second query returns instantly from cache. After clearing the cache, the same query hits the database again. The client code uses the same `DatabaseService` interface throughout, unaware that caching is happening behind the scenes.","pageType":"lld-interviews"}

Get Premium