Padrões de Projeto - PROXY

Entendendo...

O que são Padrões de Projeto?
Padrões de projeto são soluções elegantes e reutilizáveis para problemas recorrentes que encontramos diariamente no processo de desenvolvimento de aplicativos para o mundo real. Eles tratam da concepção e da interação entre objetos, definindo ao mesmo tempo um padrão de comunicação que é compartilhado por toda a equipe de desenvolvimento

Os padrões são classificados segundo o GOF(Gang of Four) em:

• Padrões de criação: abstraem o processo de criação de objetos a partir da instanciação de classes.
• Padrões estruturais: tratam da forma como classes e objetos estão organizados para a formação de estruturas maiores.
• Padrões comportamentais: preocupam-se com algoritmos e a
  atribuição de responsabilidade entre objetos.

e subclassificados em:

• Padrões de classes: em geral estáticos, definidos em tempo de compilação.
• Padrões de objetos: em geral dinâmicos, definidos em tempo
  de execução.

… entendido o que é padrões de projeto e como são classificados, vamos passar para o nosso padrão em questão.

PROXY

Fornece um objeto representante ou um marcador de outro objeto para controlar o acesso ao mesmo.

Classificação:	Estrutural
SubClassificação:	Objeto

Modos de aplicação do padrão:

Remote proxy:	Prover a representação local a um objeto em outro espaço.
Virtual proxy:	Controla a criação de objetos caros sob demanda.
Protection proxy:	Controla o acesso ao objeto real.

- A baixo um exemplo de código em C# aplicado em protection proxy.

using System;

namespace Proxy
{
class ExemploProxy
{
static void Main()
{
// Cria um objeto proxy e chama o metódo requisição da classe
Proxy proxy = new Proxy();
proxy.requisicao();
// Para mostrar o resultado
Console.ReadKey();
}
}

//-----------------------------------------------------------------------------------------//

//Classe Abstrata
abstract class Abstrata
{
public abstract void requisicao();
}

//-----------------------------------------------------------------------------------------//

//Classe ObjetoReal
//subclasse da classe Abstrata -> [ObjetoReal : Abstrata]
class ObjetoReal : Abstrata
{
// métodos com nome e parâmetros iguais devem ter o identificador 'override'
public override void requisicao()
{
Console.WriteLine("Chamando RealObjeto.requisicao()");
}
}

//-----------------------------------------------------------------------------------------//

//Classe Proxy
//subclasse da classe Abstrata -> [Proxy : Abstrata]
class Proxy : Abstrata
{
//cria um objeto privado herdando da classe ObjetoReal
private ObjetoReal _objetoReal;

// métodos com nome e parâmetros iguais devem ter o identificador 'override'
public override void requisicao()
{
// Instância o objeto se a condição for satisfeita
if (_objetoReal == null)
{
_objetoReal = new ObjetoReal();
}
//chama o metodo requisição da classe ObjetoReal
_objetoReal.requisicao();

}
}
}

Vantagens:

•Transparência: mesma sintaxe usada na comunicação entre o cliente e o objeto real é usada no proxy.

• Tratamento inteligente dos dados no cliente.

• Maior eficiência com caching no cliente.

Desvantagens:

•Pode haver impacto na performance.

• Fatores externos podem tornar o proxy inoperante ou

desatualizado.

abraç0o!