Design Patterns in C: Can you explain the Proxy design pattern and its purpose?Question For - Junior Level Developer

Related To: Structural Patterns

Direct Summary

A Proxy acts as a controlled access point or intermediary for another object. It provides a surrogate that sits between a client and a real object, intercepting requests to add functionality like access control, caching, or logging, all without modifying the real object itself.

Understanding the Proxy Design Pattern

The Proxy pattern is a structural design pattern that provides a placeholder or surrogate for another object to control access to it. It acts as an intermediary, sitting between a client and a “real” subject object. When a client interacts with the proxy, the proxy intercepts these requests, potentially adding additional functionality such as access control, caching, or logging, before or after delegating the request to the real object. The crucial benefit is that it achieves this without modifying the real object’s core logic.

Key Principles and Benefits

1. Controlled Access

A primary benefit of the Proxy pattern is its ability to manage and restrict access to the real object. This is crucial in scenarios requiring security measures. For instance, imagine a sensitive document stored on a server. A proxy can be implemented to verify user credentials before granting access to the document. This ensures that only authorized users can view or modify the sensitive information, adding a layer of security. This protection is implemented without altering the underlying document or its storage mechanism.

2. Enhanced Functionality

The Proxy pattern enhances functionality without cluttering the real object’s code. Caching is a prime example. If an image or data takes time to load, a proxy can store the information after the first load. Subsequent requests for the same resource can be served directly from the proxy’s cache, drastically improving performance. Similarly, a logging proxy can record every interaction with the real object, aiding in debugging or auditing without modifying the real object’s code. This separation of concerns promotes cleaner, more maintainable code.

3. Types of Proxies

Understanding the various proxy types is crucial for applying the pattern effectively. Here are some common types:

• Virtual Proxy: Creates expensive objects on demand. For example, loading a large image or complex data structure only when it’s actually needed, improving startup time and memory usage.
• Remote Proxy: Acts as a local representative for an object in a different address space (e.g., a web service, a remote server, or another process). It handles the complexities of network communication.
• Protection Proxy: Controls access based on roles or permissions, as demonstrated in the sensitive document example. It grants or denies access to the real object’s methods.
• Smart Reference Proxy: Adds additional actions when the real object is accessed, such as counting references to an object, loading it into memory, or locking it before access.
• Caching Proxy: Stores results of operations from the real object to improve performance for subsequent identical requests.
• Logging Proxy: Logs method calls and their parameters to the real object, useful for auditing or debugging.

Proxy vs. Decorator: A Key Distinction

For junior developers, it’s essential to understand the difference between a proxy and a decorator, as both wrap an object. While both patterns involve wrapping an object, their primary intentions differ:

• A Proxy controls access to the object. Think of it as a bouncer at a club: it decides who gets in and when.
• A Decorator adds behavior or responsibilities to an object dynamically. Think of it as adding toppings to a pizza: it enhances the existing item without changing its fundamental nature.

Let’s clarify this distinction with a scenario. Imagine you’re building a system for online purchases. A decorator might add gift-wrapping functionality to an order, enhancing its behavior without changing the core order processing. A proxy, on the other hand, might be used for payment processing. The proxy would sit between the customer’s payment information and the actual payment gateway. It might encrypt the payment details before sending them to the gateway, ensuring secure transactions. Here, the proxy controls access to the sensitive payment process and adds a security layer.

Real-world examples include a web service proxy that handles communication with a remote server or a virtual proxy that loads a large image only when displayed on the screen.

C# Code Sample: Protection and Virtual Proxy

This C# example demonstrates a Protection Proxy combined with a Virtual Proxy aspect. The DocumentProxy controls access to the RealDocument based on an authentication flag and also delays loading the RealDocument until it’s actually needed (lazy initialization).

// Subject Interface (Common interface for Real Subject and Proxy)
public interface IDocument
{
    void DisplayContent();
}

// Real Subject (The actual object containing the content)
public class RealDocument : IDocument
{
    private string content;

    public RealDocument(string content)
    {
        this.content = content;
        Console.WriteLine("RealDocument: Loading content... (Simulating an expensive operation)");
    }

    public void DisplayContent()
    {
        Console.WriteLine("RealDocument: Displaying content: " + content);
    }
}

// Proxy (The surrogate that controls access and potentially delays initialization)
public class DocumentProxy : IDocument
{
    private RealDocument realDocument;
    private string content; // Stored to create RealDocument when needed
    private bool isAuthenticated; // Example access control flag

    public DocumentProxy(string content, bool isAuthenticated)
    {
        this.content = content; // Store content info, but don't load the real object yet
        this.isAuthenticated = isAuthenticated;
        Console.WriteLine("DocumentProxy: Created, but RealDocument not loaded yet.");
    }

    public void DisplayContent()
    {
        // Protection Proxy aspect: Check authentication before proceeding
        if (!isAuthenticated)
        {
            Console.WriteLine("DocumentProxy: Access denied. Authentication required.");
            return;
        }

        // Virtual Proxy aspect: Lazy initialization (load the real object only when needed)
        if (realDocument == null)
        {
            Console.WriteLine("DocumentProxy: Authenticated. Loading RealDocument...");
            realDocument = new RealDocument(content); // Create the real object here
        }

        Console.WriteLine("DocumentProxy: Forwarding request to RealDocument.");
        realDocument.DisplayContent(); // Delegate the call to the real object
    }
}

// Client Code (How the client interacts with the Proxy)
public class Client
{
    public static void Main(string[] args)
    {
        Console.WriteLine("--- Scenario 1: Unauthenticated Access ---");
        Console.WriteLine("Client: Trying to access document without authentication.");
        IDocument doc1 = new DocumentProxy("Confidential Report", false);
        doc1.DisplayContent(); // Expected: Access denied, RealDocument not loaded

        Console.WriteLine("\n--- Scenario 2: Authenticated Access ---");
        Console.WriteLine("Client: Trying to access document with authentication.");
        IDocument doc2 = new DocumentProxy("Confidential Report", true);
        doc2.DisplayContent(); // Expected: Access granted, RealDocument loaded

        Console.WriteLine("\n--- Scenario 3: Re-accessing Authenticated Document ---");
        Console.WriteLine("Client: Accessing the same document again (should not reload RealDocument).");
        doc2.DisplayContent(); // Expected: Access granted, RealDocument already loaded
    }
}