O padrão Proxy é utilizado para fornecer um “representante” ou “substituto” de um objeto real, controlando o acesso a ele. É útil quando você deseja adiar a criação de um objeto pesado ou proteger o acesso a ele, controlando suas operações. Um exemplo comum seria o carregamento de imagens: o Proxy pode carregar uma miniatura ou placeholder inicialmente e, quando necessário, carregar a imagem completa.
Exemplo de Código em C#:
// Interface que define as operações da imagem
public interface IImagem
{
void Exibir();
}
// Classe que representa a imagem real, que é "pesada" para carregar
public class ImagemReal : IImagem
{
private string _caminhoArquivo;
public ImagemReal(string caminhoArquivo)
{
_caminhoArquivo = caminhoArquivo;
CarregarImagem();
}
private void CarregarImagem()
{
Console.WriteLine($"Carregando imagem do arquivo {_caminhoArquivo}...");
}
public void Exibir()
{
Console.WriteLine($"Exibindo imagem {_caminhoArquivo}.");
}
}
// Classe Proxy que controla o acesso à ImagemReal
public class ProxyImagem : IImagem
{
private ImagemReal _imagemReal;
private string _caminhoArquivo;
public ProxyImagem(string caminhoArquivo)
{
_caminhoArquivo = caminhoArquivo;
}
public void Exibir()
{
// Carregar a imagem real apenas quando for necessária
if (_imagemReal == null)
{
_imagemReal = new ImagemReal(_caminhoArquivo);
}
_imagemReal.Exibir();
}
}
class Program
{
static void Main(string[] args)
{
// Criar uma imagem proxy
IImagem imagem = new ProxyImagem("foto.jpg");
// A imagem real só será carregada quando for realmente exibida
Console.WriteLine("Imagem criada, mas ainda não carregada.");
imagem.Exibir(); // Carregando e exibindo a imagem real
imagem.Exibir(); // A imagem já está carregada, então só será exibida
}
}
Explicação do Código:
Aqui temos a classe ImagemReal, que representa uma imagem “pesada” que precisa ser carregada de um arquivo. O ProxyImagem controla o acesso a essa imagem real e carrega a imagem apenas quando for necessário, economizando recursos. Quando chamamos o método Exibir pela primeira vez, a imagem real é carregada e exibida; nas chamadas subsequentes, o Proxy já possui a imagem carregada e apenas a exibe.
Conclusão:
O padrão Proxy é útil quando você precisa controlar o acesso a um objeto que é pesado ou sensível. Ele pode atrasar a criação de objetos até que sejam realmente necessários ou controlar o uso de um recurso de maneira eficiente.
Código fonte: GitHub
Top comments (0)