Implementando o Registry Pattern

Bom, pessoal, hoje vamos implementar do zero o pattern de arquitetura Registry.

O Registry nada mais � do que uma esp�cie de buscador de objetos, ou seja, um localizador. O Registry sabe onde se encontram os objetos que voc� precisa, esta � a funç�o dele. Voc� pode utiliz�-lo quando houver a necessidade de ter um objeto que sabe procurar e achar os objetos que precisam ser localizados e utilizados. O registry tamb�m � importante por que com ele voc� pode obter invers�o de controle, ou seja, voc� passa a ele o controle e responsabilidade de encontrar os objetos. Voc� apenas solicita a ele e o mesmo retorna o objeto para voc�. Mas chega de bl� bl� bl� e vamos meter a m�o na massa. Observe o diagrama abaixo:

Figura 1: Diagrama de classes do padr�o Registry

Vamos começar a �dissecar� a soluç�o. Veja que temos uma classe Registry que ser� chamada por qualquer camada, haja vista, o registry tamb�m pode ser utilizado como um service locator, e desta maneira pode ser acessado por qualquer camada da aplicaç�o. Ele faz uso de um container, que � quem armazena os objetos que implementam as abstraç�es. O Registry ir� solicitar ao container que resolva uma determinada abstraç�o (inteface ou classe abstrata). Note que restamos aqui utilizando a invers�o de controle, o registry n�o faz refer�ncia a uma implementaç�o, e sim a uma abstraç�o de um contaner. Existem v�rios containers no mercado, structured map, castle windsor, unity da Microsoft, enfim, uma infinidade de containers de injeç�o de depend�ncia. O fato de apontarmos para uma abstraç�o faz com que, independente do container, o que importa � existir algu�m a quem o registry possa pedir para resolver a abstraç�o. Temos ainda uma classe para nos auxiliar a obter as abstraç�es e suas respectivas abstraç�es.

O Registry

Veremos o c�digo do registry abaixo:

Listagem 1: Implementaç�o da classe Registry

 public class Registry
{
	public Registry()
	{
		this.Container = new UnityDIContainer();
	}
	
	private IDIContainer Container;
	
	public TAbstraction getServiceImplementation<TAbstraction>()
	{
		return this.Container.Resolve<TAbstraction>();
	}
}

Note que o container aponta para uma abstraç�o de um container, ou seja, n�o importa quem ele �, o importante � ele ser capaz de resolver a depend�ncia/abstraç�o. Dentro do construtor, � instanciada uma implementaç�o da interface IDIContainer, que utiliza o Unity da Microsoft para container de injeç�o de depend�ncia. � responsabilidade do container armazenar as abstraç�es (interfaces/classes abstratas) para que possam ser recuperadas quando necess�rio.

IDIContainer

Como dito anteriormente, a funç�o do container � simplesmente armazenar as abstraç�es e suas respectivas implementaç�es. Veja o c�digo abaixo:

Listagem 2: Interface IDIContainer

 public interface IDIContainer
{
	void ResgiterType(Type pAbstraction, Type pImplementation);
	TAbstraction Resolve<TAbstraction>();
}

Veja que o contrato � simples, um m�todo para registrar a abstraç�o a alguma classe que a implemente, e um m�todo para recuperar alguma classe que resolva, ou seja, implemente uma determinada abstraç�o.

Implementando o IDIContainer

A implementaç�o n�o tem nenhum mist�rio, precisamos apenas obter as classes e abstraç�es referenciados no projeto em que se encontra o container. Veja o c�digo da implementaç�o para o Unity abaixo:

Listagem 3: Implementaç�o do Container


public class UnityDIContainer : IDIContainer
{	
	private IUnityContainer _fContainer;
	
	public UnityContainer()
	{
		this._fContainer = new UnityContainer();
		this.registraClasses();
	}

	private void registraClasses()
	{	
		var objHelper = new AssemblerHelper();
		foreach(var vAbstracao in objHelper
		.obterAbstracoesNosAssempliesReferenciados())
		{
			 foreach(var vClasseImplAbstracao in objHelper.
listaImplementacoesAbstracao(vAbstracao))
			{
				this._fContainer.RegisterType(vAbstracao, vClasseImplAbstracao);
			}
		}
	}

	public void RegisterType(Type pAbstraction, Type pImplementacao)
	{
		this._fContainer.RegisterType(pAbstraction, pImplementation);
	}

	public TAbstraction Resolve<TAbstraction>()
	{
		return this._fContainer.Resolve<TAbstraction>();
	}
}

A implementaç�o consiste apenas em encontrar as classes e abstraç�es e mapear no container, no caso desta implementaç�o do Unity. Veja que no construtor � chamado o m�todo registraClasses, que usa a classe AssemblyHelper para obter todas as abstraç�es referenciadas no projeto, mapeando para as respectivas implementaç�es.

M�todos da interface

Register Type: Registra a abstraç�o para uma implementaç�o.
Resolve: Retorna uma implementaç�o de uma determinada abstraç�o.

AssemblyHelper

A classe Assemblyhelper recupera todas as abstraç�es e implementaç�es referenciadas no projeto em que se encontra a implementaç�o do container. � importante, para que o registry possa utilizar o container, que voc� referencie as DLLs em que se encontram as classes e interfaces que voc� deseja mapear. C�digo do Assemblyhelper abaixo:

Listagem 5: Classe AssemblyHelper


public class AssemblyHelper
{
    public IList<Assembly> obterAssemblies()
    {
        var listAssemblyRetorno = new List<Assembly>();
        var objDirInfoRelease = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
        var objDirInfoBin = objDirInfoRelease.Parent;
 
        var arquivoDLL = objDirInfoRelease.GetFiles();
 
        foreach (var fileInfo in arquivoDLL)
        {
            if (fileInfo.FullName.Contains(".dll"))
            {
                Assembly objAssembly = Assembly.LoadFrom(fileInfo.FullName);
                listAssemblyRetorno.Add(objAssembly);
            }
        }
 
        return listAssemblyRetorno;
    }
 
    public IList<Type> obterClassesPorAssembly(Assembly pAssembly)
    {
        IList<Type> listaClassesAssembly = new List<Type>();
 
        foreach (var vType in pAssembly.GetTypes())
        {
            if (vType.IsClass)
            {
                listaClassesAssembly.Add(vType);
            }
        }
 
        return listaClassesAssembly;
    }
 
    public IList<Type> obterInterfacesPorAssembly(Assembly pAssembly)
    {
        IList<Type> listaInterfacesAssembly = new List<Type>();
 
        foreach (var vType in pAssembly.GetTypes())
        {
            if (vType.IsInterface)
            {
                listaInterfacesAssembly.Add(vType);
            }
        }
 
        return listaInterfacesAssembly;
    }
 
    public IList<Type> obterAbstracoesPorAssembly(Assembly pAssembly)
    {
        IList<Type> listaInterfacesAssembly = new List<Type>();
 
        foreach (var vType in pAssembly.GetTypes())
        {
            if (vType.IsInterface)
            {
                listaInterfacesAssembly.Add(vType);
            }
            else if (vType.IsClass && vType.IsAbstract)
            {
                listaInterfacesAssembly.Add(vType);
            }
        }
 
        return listaInterfacesAssembly;
    }
 
    public IList<Type> listaImplementacoesAbstracao(Type pTipoInterface)
    {
        IList<Type> listaImplInterface = new List<Type>();
 
        foreach (var vAssemblies in this.obterAssemblies())
        {
            foreach (var vClasse in this.obterClassesPorAssembly(vAssemblies))
            {
                if (vClasse.GetInterface(pTipoInterface.Name) != null)
                    listaImplInterface.Add(vClasse);
            }
        }
 
        return listaImplInterface;
    }
 
    public IList<Type> obterAbstracoesNosAssembliesReferenciados()
    {
        IList<Type> listaAbstracoes = new List<Type>();
 
        foreach (var vAssemblies in this.obterAssemblies())
        {
            foreach (var vInterface in this.obterAbstracoesPorAssembly(vAssemblies))
            {
                listaAbstracoes.Add(vInterface);
            }
        }
 
        return listaAbstracoes;
    }
 
    public bool TypeFilter(Type pTipo, object pObjetoFiltro)
    {
        return pTipo.Name == pObjetoFiltro.GetType().Name;
    }
}

Um detalhe importante na implementaç�o deste pattern � que al�m de ter um objeto localizador, devemos buscar separar as responsabilidades. Se voc� notar, cada classe faz o seu papel e pede que as outras colaborem quando necess�rio. � a� que vemos como princ�pios como o da responsabilidade �nica, invers�o de controle e injeç�o de depend�ncia tem seu valor. Se amanh� mudarmos de container e quisermos utilizar o Castle Windsor, por exemplo, basta apenas criar uma classe que implemente a interface IDIContainer e mudar uma linha de c�digo no construtor do registry, por exemplo:

Listagem 6: Alterando o tipo de container


 public Registry()
{
   this.Container = new WindsorDIContainer();
}

Bom, pessoal, vamos ficando por aqui. Espero que voc�s tenham gostado do artigo e me coloco a disposiç�o para quaisquer esclarecimentos. Abraços e at� a pr�xima.