Autofac – trabalhando com eventos

Facebooktwittergoogle_plusredditpinterestlinkedinmail

Hoje vamos falar sobre eventos de ciclo de vida (Lifetime events) do Autofac, o container de inversão de controle que já vimos antes aqui. O Autofac nos permite assinar três eventos durante o processo de registro dos componentes, sendo eles: OnActivating, OnActivated e OnRelease.

OnActivating

É disparado antes de um componente ser utilizado e pode ser usado para:
-Trocar a instância que será devolvida pelo Autofac
-Fazer injeção de propriedades ou de métodos
-Realizar outros tipos de tarefas de inicialização

OnActivated

É disparado assim que o componente acaba de ser completamente construído. Pode ser usado em tarefas que precisem que o componente esteja completamente construído, o que não é usual, devendo ser raro precisar usar esse tipo de evento.

OnRelease

É disparado quando o ciclo de vida do componente chega ao fim, e deve ser usado para liberar recursos usados pelo componente.

Agora vamos ver como utilizar esses eventos na prática? Vamos usar como base para nosso exemplo, a aplicação construída anteriormente, quando mostramos aqui como usar o Autofac em conjunto com WCF. Para isso, baixe a aplicação no GitHub: https://github.com/rdakar/autofac-wcf

Abra a aplicação no Visual Studio, e crie uma nova classe, chamada DoLog, de acordo com o código abaixo:

namespace AutofacDemoWCF
{
    public class DoLog
    {
        public void Write(string s) => Debug.Write(s);
    }
}

É uma simples classe que simplesmente imprime no console o valor de uma string. Agora vamos alterar o arquivo Global.asax, para registrar nossa classe DoLog, porém, em vez de registrarmos como “InstancePerLifetimeScope”, vamos registrá-la como “SingleInstance”, dessa forma, teremos apenas uma instância para a classe DoLog durante todo ciclo de vida do container, diferente de Soma, que teremos uma nova instância a cada vez que ela for solicitada. Então acrescente essa linha ao método Application_Start:

builder.RegisterType<DoLog>().AsSelf().SingleInstance().OnActivating(c => Debug.Write("OnActivating: DoLog")).OnActivated(c => Debug.Write("OnActivated: DoLog")).OnRelease(c => Debug.Write("OnRelease: DoLog"));

Além disso, altere a linha que registra a classe Soma, para ficar dessa forma:

builder.RegisterType<Soma>().As<ICalculo>().InstancePerLifetimeScope().OnActivating(c => Debug.Write("OnActivating: Soma")).OnActivated(c => Debug.Write("OnActivated: Soma")).OnRelease(c => Debug.Write("OnRelease: Soma"));

Repare, que implementamos os três eventos citados acima no registro de cada uma das classes, fizemos isso usando lambda expression. A outra forma de utilizar esses eventos, é fazer com que a classe desejada implemente a interface IComponentRegistration.

Legal, agora vamos alterar a classe Service1, para utilizar nossa classe de log, para isso declare uma variável do tipo DoLog conforme abaixo:

private DoLog _log;

E altere o construtor da classe para injetar a classe DoLog:

public Service1(ICalculo calculo, DoLog log)
{
    this._calculo = calculo;
    this._log = log;
}

Agora altere o método GetSoma para que fique assim:

public double GetSoma(double a, double b)
{
    _log.Write("Método GetSoma");
    return _calculo.Calcular(a, b);
}

Agora vamos executar nosso serviço usando o WCF Test Client, e vamos invokar o método GetSoma duas vezes e analisar o resultado no console. Você deve ter uma saída mais ou menos assim:

OnActivating: Soma
OnActivating: DoLog
OnActivated: Soma
OnActivated: DoLog
Método GetSoma
OnRelease: Soma
OnActivating: Soma
OnActivated: Soma
Método GetSoma
OnRelease: Soma

Repare que para a classe Soma, para cada chamada que fizemos ao método GetSoma o Autofac disparou os eventos OnActivating, OnActivated e OnRelease. Ja para nossa classe DoLog, repare que ele disparou apenas uma vez os eventos OnActivating e OnActivated, e nenhuma vez o evento OnRelease, que só será chamado quando nossa aplicação for encerrada.

Viu como é simples manipularmos os eventos que o Autofac dispara quando está registrando os componentes? Com os eventos temos um controle bem refinado de nossa aplicação, nos permitindo trocar a instância que o container devolverá, ou fazer injeção de propriedades e métodos, que veremos com mais detalhes aqui em breve.

O código completo do exemplo está publicado no GitHub: https://github.com/rdakar/autofac-trabalhando-com-eventos

Facebooktwittergoogle_plusredditpinterestlinkedinmail

1 thought on “Autofac – trabalhando com eventos

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *