How do the Proxy and Decorator patterns differ in their purpose and implementation in C ? Question For - Mid Level Developer

Related To: Structural Patterns, Proxy Pattern, Decorator Pattern

Direct Summary

Both Proxy and Decorator are structural design patterns that involve wrapping an object. However, a Proxy controls access to an object, acting as a surrogate, while a Decorator adds behavior or responsibilities dynamically. A Proxy typically maintains the same interface as the wrapped object, whereas a Decorator can extend it. Essentially, a Proxy acts as a gatekeeper, and a Decorator enhances functionality.

Understanding the Core Differences

While both the Proxy and Decorator patterns involve wrapping an object, their core purposes and implementation nuances differ significantly. Understanding these distinctions is crucial for applying them correctly in C# development.

Key Differences

Interview Preparation Tips

When discussing these patterns in an interview, demonstrating a clear understanding of their distinct intents and real-world applicability is key.

Code Sample (C#)

// IService is the common interface for both RealService, Proxy, and Decorators
public interface IService
{
    void Request();
}

// The core service that performs the actual work
public class RealService : IService
{
    public void Request()
    {
        Console.WriteLine("Executing RealService Request");
    }
}

// --- Proxy Example ---
// ServiceProxy controls access to RealService
public class ServiceProxy : IService
{
    private RealService _realService; // Holds a reference to the real subject

    public void Request()
    {
        // Control access or add operations before/after
        Console.WriteLine("Proxy: Checking access...");
        if (CheckAccess()) // Access control logic
        {
            // Lazy initialization: create RealService only when needed
            if (_realService == null)
            {
                _realService = new RealService();
            }
            _realService.Request(); // Delegate the request to the real service
            Console.WriteLine("Proxy: Logging request."); // Additional operation (e.g., logging)
        }
        else
        {
            Console.WriteLine("Proxy: Access denied.");
        }
    }

    private bool CheckAccess()
    {
        // Dummy access check for demonstration
        return true;
    }
}

// --- Decorator Example ---
// BaseService acts as the ConcreteComponent for the Decorator pattern
public class BaseService : IService
{
    public virtual void Request()
    {
        Console.WriteLine("Executing BaseService Request");
    }
}

// Abstract Decorator class: implements the common interface and holds a reference
// to the decorated component.
public abstract class ServiceDecorator : IService
{
    protected IService _decoratedService; // Reference to the wrapped component

    public ServiceDecorator(IService service)
    {
        _decoratedService = service;
    }

    public virtual void Request()
    {
        _decoratedService.Request(); // Delegates the call to the wrapped object
    }
}

// Concrete Decorator 1: Adds Logging functionality
public class LoggingDecorator : ServiceDecorator
{
    public LoggingDecorator(IService service) : base(service) { }

    public override void Request()
    {
        Console.WriteLine("LoggingDecorator: Before Request");
        base.Request(); // Call the wrapped service's method (which might be another decorator or the base service)
        Console.WriteLine("LoggingDecorator: After Request");
    }
}

// Concrete Decorator 2: Adds Caching functionality (simplified for demonstration)
public class CachingDecorator : ServiceDecorator
{
    private Dictionary<string, object> _cache = new Dictionary<string, object>(); // Dummy cache

    public CachingDecorator(IService service) : base(service) { }

    public override void Request()
    {
        string cacheKey = "RequestResult"; // Simple key for demonstration

        if (_cache.ContainsKey(cacheKey))
        {
            Console.WriteLine("CachingDecorator: Serving from cache.");
            // In a real scenario, return cached result
        }
        else
        {
            Console.WriteLine("CachingDecorator: Not in cache, executing...");
            base.Request(); // Call the wrapped service's method
            // In a real scenario, cache the result
            _cache[cacheKey] = "Cached Result"; // Dummy cache entry
            Console.WriteLine("CachingDecorator: Result cached.");
        }
    }
}

/*
// How to use them:

// Using Proxy
Console.WriteLine("--- Using Proxy ---");
IService proxy = new ServiceProxy();
proxy.Request(); // Access control and lazy init handled by proxy
Console.WriteLine();

// Using Decorators
Console.WriteLine("--- Using Decorators ---");
IService baseService = new BaseService(); // The original component
IService serviceWithLogging = new LoggingDecorator(baseService); // Add logging
// Layering decorators: Add caching on top of the logging-enabled service
IService serviceWithLoggingAndCaching = new CachingDecorator(serviceWithLogging);

serviceWithLoggingAndCaching.Request(); // This will trigger caching, then logging, then base service
Console.WriteLine();

// Request again to show caching (in a real cache, this would bypass the inner calls)
serviceWithLoggingAndCaching.Request();
*/