Proxy Pattern

Proxy pattern provides placeholder for another object to access it. It provides wrapper and delegation to protect actual object and its complexity from end user. Proxy pattern falls under structural pattern of GOF (Gang of Four) pattern.

When to use –

Proxy pattern can be used when you want to access remote object using local object. The remote object can be from network, file, service or any other object. Proxy acts as wrapper for simplifying complex objects and provides simpler way to access it. Proxy can also be used to provide additional functionality over actual object without changing real object’s code like adding thread safety to actual object.

Below are types of proxy.

• Virtual Proxy – This type of proxy can be used to create objects that are heavy and complex. So using virtual proxy you can create them on demand.
• Remote Proxy – This type of proxy provides local interface for an object that is in remote location (in different address space). The example of remote proxy is the use of WCF/Web service where client accessing remote code located on different server on different network.
• Protection Proxy – This type of proxy can be used when you want add authentication mechanism for client to access real object.
• Smart Proxy – This type of proxy can be used to add additional functionality to manage resources efficiently. For example, counting number of references to real object, making real object thread safe etc.

Major components of Proxy pattern –

Subject – This is an interface provides abstract methods to access using proxy class.

Real Subject – This is concrete class which implements subject interface.

Proxy – This is proxy class and used by client to access real object. Proxy class has reference to actual object and resources.

See below example of proxy pattern.

Code –

//subject

public interface IPayment

{

    void PayAmount(double amount);

}

//real subject

public class CashPayment : IPayment

{

    public void PayAmount(double amount)

    {

        Console.WriteLine("The amount of Rs. {0} paid in cash", amount);

    }

}

//proxy class

public class CardPayment : IPayment

{

    CashPayment cashPay;

    public void PayAmount(double amount)

    {

        if (cashPay == null)

            cashPay = new CashPayment();

        cashPay.PayAmount(amount);

    }

}

//client

class Program

{

    static void Main(string[] args)

    {

        IPayment payment = new CardPayment();

        payment.PayAmount(5000);

        Console.ReadLine();

    }

}

Output –

As you can see in above example, CardPayment class acts as proxy class. CardPayment class has referent to real object which is CashPayment. So whenever you pay amount using CardPayment proxy class which actually pay amount from real object which is CashPayment. So CardPayment class acts as intermediate/wrapper between CashPayment and Client.

I hope this article helps you to know more about Proxy Pattern. Please leave your feedback in comments section below.

References –

DoFactory

See Also –

Creational Patterns	Structural Patterns	Behavioral Patterns
Singleton Pattern	Adapter Pattern	Chain of Responsibility Pattern
Thread safe singleton pattern	Bridge Pattern	Command Pattern
Factory Pattern	Composite Pattern	Interpreter Pattern
Abstract Factory Pattern	Decorator Pattern	Iterator Pattern
Builder Pattern	Facade Pattern	Mediator Pattern
Prototype Pattern	Flyweight Pattern	Memento Pattern
	Proxy Pattern	Observer Pattern
		State Pattern
		Strategy Pattern
		Template Method Pattern
		Visitor Pattern