Proxy - Design Pattern

Objective 🎯

Provide a substitute for another object to control access to it.

Type ✅

❌Behavioral: Describes how objects interact/communicate between themselves.

❌Creational: Describes how to instantiate an object without large and complex.

✔️Structural: Describes how objects/classes are composed to form larger structures.

UML 📐

Participants 🔗

• Subject:

• Defines an interface common for both Real and Proxy subject so that Proxy can be used anywhere a Real object is expected.

• RealSubject:

• Implements the real operations that proxy will represent.

• Proxy:

• Maintains a reference to RealSubject
• Forward method calls to RealSubject

Sample Code 🎮

Structural Example 🏛️

public static class ProxyStructural
    {
        public static void Execute()
        {
            Proxy lProxy = new Proxy();
            lProxy.Request();
        }
    }

    internal abstract class Subject
    {
        public abstract void Request();
    }

    internal class RealSubject : Subject
    {
        public override void Request()
        {
            Console.WriteLine("Called RealSubject.Request()");
        }
    }

    internal class Proxy : Subject
    {
        private RealSubject _RealSubject;

        public override void Request()
        {
            if (_RealSubject == null)
                _RealSubject = new RealSubject();

            _RealSubject.Request();
        }
    }

Output

Real-world Example 🔥

namespace Main.Proxy
{
    public static class ProxyPractical
    {
        public static void Execute()
        {
            Calculator lCalculator = new ProxyCalculator();

            Console.WriteLine($"Proxy Calculator - Calling method \"Add\" in the Real Calculator... Result: 5 + 7 = {lCalculator.Add(5,7)}");
            Console.WriteLine($"Proxy Calculator - Calling method \"Add\" in the Real Calculator... Result: 5 - 7 = {lCalculator.Subtract(5, 7)}");
            Console.WriteLine($"Proxy Calculator - Calling method \"Add\" in the Real Calculator... Result: 5 * 7 = {lCalculator.Multiply(5, 7)}");
            Console.WriteLine($"Proxy Calculator - Calling method \"Add\" in the Real Calculator... Result: 5 / 7 = {lCalculator.Divide(5, 7)}");
        }
    }

    public abstract class Calculator
    {
        public abstract float Add(float prNumber1, float prNumber2);
        public abstract float Subtract(float prNumber1, float prNumber2);
        public abstract float Multiply(float prNumber1, float prNumber2);
        public abstract float Divide(float prNumber1, float prNumber2);
    }

    public class RealCalculator : Calculator
    {
        public override float Add(float prNumber1, float prNumber2)
        {
            return prNumber1 + prNumber2;
        }

        public override float Divide(float prNumber1, float prNumber2)
        {
            return prNumber1 / prNumber2;
        }

        public override float Multiply(float prNumber1, float prNumber2)
        {
            return prNumber1 * prNumber2;
        }

        public override float Subtract(float prNumber1, float prNumber2)
        {
            return prNumber1 - prNumber2;
        }
    }

    public class ProxyCalculator : Calculator
    {
        private RealCalculator _RealCalculator;

        public ProxyCalculator()
        {
            _RealCalculator = new RealCalculator();
        }

        public override float Add(float prNumber1, float prNumber2)
        {
            return _RealCalculator.Add(prNumber1, prNumber2);
        }

        public override float Divide(float prNumber1, float prNumber2)
        {
            return _RealCalculator.Divide(prNumber1, prNumber2);
        }

        public override float Multiply(float prNumber1, float prNumber2)
        {
            return _RealCalculator.Multiply(prNumber1, prNumber2);
        }

        public override float Subtract(float prNumber1, float prNumber2)
        {
            return _RealCalculator.Subtract(prNumber1, prNumber2);
        }
    }
}

Output

Source Code 🎲

https://github.com/VictorLins/DesignPatterns