No post sobre Introdução à DI com Enterprise Library 5.0 mostramos o funcionamento do MS Unity utilizando a injeção de dependência. Neste nosso Post de hoje, mostraremos como você pode deixar sua estrutura mais flexivel utilizando as configurações por classes de Atributos. Então, abra o projeto do post anterior e adicione a seguinte classe:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Microsoft.Practices.Unity;

namespace DependencyInjectionUnity
{
public class RegistradorDeLogs
{
public ILogger Logger { get; set; }

[InjectionMethod]
public void Inicializador(ILogger logger)
{
this.Logger = logger;
}

public void RegistrarLog(string mensagemLog)
{
this.Logger.RegisterMessage(mensagemLog);
}
}
}

A classe criada acima, é quem de fato vai trabalhar com as injeções de dependência. Como assim? Se você perceber, a classe possui uma propriedade do tipo ILogger, onde por meio da chamada ao método Inicializador, será passada uma referência, por injeção, da classe que está implementando a Interface ILogger, no momento que estivermos resolvendo a classe RegistradorDeLogs. Além disso, estamos fazendo uso da classe de atributo InjectionMethodAttribute, como mostrado no código acima. É devido à este atributo que conseguimos resolver a dependência. O método que ela está usando para a injeção de dependência, chama-se: Method Call Injection. O MS Unity possui 3 tipos de injeção de dependência:

- Constructor Injection

- Property Injection

- Method Call Injection

Faremos agora uma alteração na Interface, como mostrado no código abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DependencyInjectionUnity
{
public interface ILogger
{
void RegisterMessage(string mensagem);
}
}

Feita esta alteração, vamos alterar as nossas classes de implementação da Interface, como apresentado nos trechos de códigos abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DependencyInjectionUnity
{
public class LoggerWeb : ILogger
{
#region ILogger Members

public void RegisterMessage(string mensagem)
{
Console.WriteLine(mensagem);
}

#endregion
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DependencyInjectionUnity
{
public class LoggerWindows : ILogger
{
#region ILogger Members

public void RegisterMessage(string mensagem)
{
Console.WriteLine(mensagem);
}

#endregion
}
}

Pronto, estamos quase lá. Agora precisamos alterar as chamadas no método Main, do nosso arquivo Program.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Unity;

namespace DependencyInjectionUnity
{
class Program
{
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
container.RegisterType<ILogger, LoggerWindows>();
//container.RegisterType<ILogger, LoggerWeb>();

var registradorDeLogs = container.Resolve<RegistradorDeLogs>();
registradorDeLogs.RegistrarLog("Log da aplicação Windows");
//ILogger loggerWeb = container.Resolve<LoggerWeb>();

//loggerWindows.RegisterMessage("");
//loggerWeb.RegisterMessage();

Console.ReadKey();
}
}
}

Aqui no método main tivemos uma pequena alteração na chamada ao método Resolve do objeto container, onde agora estamos passando como Tipo genérico a classe RegistradorDeLogs, pois esta classe implementa a injeção de dependência no método Inicializador. PRONTO ! agora podemos executar a aplicação e verificar, em Debug, que todo o código foi executado com base no ensinamento que fizemos ao container de DI do Unity.

Espero que tenham gostado do post.

Até o próximo :D

Exibições: 144

Comentar

Você precisa ser um membro de DevBrasil para adicionar comentários!

Entrar em DevBrasil

© 2018   Criado por Ramon Durães.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço