C# - Apresentando o padrão Proxy

Hoje vou apresentar o padrão de projeto Estrutural Proxy e a sua implementação na linguagem C#.

O padrão de design de Proxy pode ser usado em situações em que você gostaria de adiar a instanciação de uma classe até o momento em que for necessária.

O proxy é um objeto que pode ser usado para controlar o acesso a um recurso remoto ou a um objeto mais complexo, ou seja, um objeto cuja criação ou operações consumiriam mais recursos.

Os objetos proxy podem ser dos seguintes tipos:

Proxy remoto - Proxies remotos codificam a solicitação e, em seguida, enviam a solicitação codificada para o objeto real.
Proxy virtual - Os proxies virtuais são normalmente usados quando o objeto real é caro para se criar. Para conservar os recursos do cliente, eles adiam a instanciação do objeto real até que seja realmente necessário; ou seja, a instanciação é feita apenas sob demanda.
Proxy de proteção - Os Proxies de proteção são usados para restringir o acesso a um recurso. Se o chamador da solicitação não tiver a permissão necessária para acessar o recurso, o acesso será negado.

Este padrão faz parte do catálogo GoF sendo definido da seguinte forma: "Fornece um substituto ou placeholder para outro objeto para controlar o acesso a ele."

O seu objetivo principal é encapsular um objeto através de um outro objeto que possui a mesma interface, de forma que o segundo objeto, conhecido como “Proxy”, controla o acesso ao primeiro, que é o objeto real.

A palavra Proxy significa 'no lugar de' ou 'em nome de' ou 'representando'.

Quando usar o padrão Proxy em sua aplicação ?

A seguir estão alguns dos cenários em tempo real onde você pode usar o padrão de design de proxy.

Adicionar acesso de segurança a um objeto existente. O proxy determinará se o cliente pode acessar o objeto de interesse;
Simplificar a API de objetos complexos. O proxy pode fornecer uma API simples para que o código do cliente não tenha que lidar com a complexidade do objeto de interesse;
Fornecer interfaces para recursos remotos, como serviço da web ou recursos REST;
Coordenar operações caras em recursos remotos, pedindo aos recursos remotos para iniciar a operação o mais rápido possível antes de acessar os recursos.

Abaixo temos o diagrama de classes do Padrão Proxy:

Vamos entender :

Subject: Esta classe fornece uma interface que tanto a classe real quanto a classe proxy irão implementar. desta forma, o proxy pode ser facilmente usado como substituto do sujeito real;

Proxy: Esta classe será utilizada pelos aplicativos e irá expor os métodos expostos pelo Subject. A aplicação usará esta classe e esta classe cuidará internamente de falar com o RealSubject e obterá os dados para a aplicação local;

RealSubject: Este é o objeto real que contém a lógica real para recuperar os dados e/ou funcionalidade. Esta é a classe que o proxy representa no final do aplicativo.

Implementando o padrão Proxy

Vamos agora implementar o padrão proxy usando a linguagem C# de uma forma bem simples.

Para isso vamos criar um projeto Console do tipo .NET Core usando o ambiente do .NET 5.0 usando o VS 2019 Community.

Os participantes em uma implementação típica do padrão de design de proxy são : Proxy, o Subject e o RealSubject.

Enquanto o Proxy mantém uma referência para acessar o RealSubject, o Subjcet é o tipo que define a interface comum para o Proxy e o RealSubject.

Vamos criar uma interface chamada ICalcular que define um contrato para implementar o método OperacaoComplexa():

    public interface ICalcular
    {
        double OperacaoComplexa(double x, double y);
    }

A seguir a classe Subject implementa a interface ICalcular :

    public class Subject : ICalcular
    {
        public double OperacaoComplexa(double x, double y)
        {
            return (x + y) / 2;
        }
    }

Agora vamos criar a classe Proxy, que no caso será um proxy de proteção, onde vamos fazer a autenticação do usuário onde somente os usuários autenticados poderão acessar o método OperacaoComplexa();

    public class Proxy : ICalcular
    {
        public bool IsAutenticado { get; private set; }

        private Subject subject = new Subject();

        public double OperacaoComplexa(double x, double y)
        {
            if (IsAutenticado)
                return subject.OperacaoComplexa(x, y);
            else
                return 0;
        }
        public bool Autenticar(string senha)
        {
            if (senha == "senhaSecreta123")
            {
                IsAutenticado = true;
                return true;
            }
            else
                return false;
        }
    }

Agora podemos invocar o proxy e realizar a autenticação para poder chamar o método implementado:

using System;

namespace CShp_Proxy1
{
    class Program
    {
        static void Main(string[] args)
        {
            Proxy proxySeguranca = new Proxy();
            proxySeguranca.Autenticar("senhasecreta123");

            Console.WriteLine(proxySeguranca.OperacaoComplexa(55.53, 14.37));

            Console.Read();
        }
    }
}

Aqui estamos invocando o Proxy e realizando a autenticação do usuário.

Abaixo vemos o diagrama de classes do projeto gerado pelo VS 2019:

Essa implementação é bem ingênua mas mostra de forma simples como usar o proxy.

"Então os justos resplandecerão como o sol, no reino de seu Pai. Quem tem ouvidos para ouvir, ouça."
Mateus 13:43

Referências:

José Carlos Macoratti