C# Design Pattern: Proxy (Portugues)

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