A Simple implementation of the Proxy Design Pattern using C#

A proxy is an object that can be used to control creation and access of a more complex object thereby deferring the cost of
creating it until the time its needed.

Below is a simple implementation of the proxy pattern in C#. The ComplexProtectedExpensiveResource is private to the
ProxyContainer and cannot be instantiated by a client. The client creates an instance of the SimpleProxy class which controls
its access to the more complex and expensive to create ComplexProtectedExpensiveResource class.

Note that the ComplexProtectedExpensiveResource is created by the SimpleProxy instance only when needed and after
verifying that the client indeed has access to it.

namespace Patterns { class ProxyContainer { private class ComplexProtectedExpensiveResource { internal void DoWork() { //do some heavy lifting } }

    // The Proxy
    public class SimpleProxy
    {
        ComplexProtectedExpensiveResource \_complexProtectedResource;
        private string \_password;

        public SimpleProxy(string password)
        {
            \_password = password;
        }

        public void DoWork()
        {
            if (Authenticate())
            {
                \_complexProtectedResource.DoWork();    
            }
        }

        bool Authenticate()
        {
            //authenticate request
            if (\_password == "password")
            {
                //create expensive object if authenticated
                if (\_complexProtectedResource == null)
                    \_complexProtectedResource = new ComplexProtectedExpensiveResource();
                return true;
            }
            return false;
        }
    }
}

// The Client
class ProxyPattern : ProxyContainer
{
    static void DoWork()
    {
       var simpleProxy = new SimpleProxy("password");
       simpleProxy.DoWork();
    }
}

}