TNF

Árvore de páginas

Você está vendo a versão antiga da página. Ver a versão atual.

Comparar com o atual Ver Histórico da Página

« Anterior Versão 2 Próxima »

No C# uma classe pode definir comportamentos a serem disparados quando determinada ação acontece e outras classes podem registrá-los para ser notificados quando isso acontecer.

Os eventos de domínio podem ser usados para desacoplar a lógica de negócio reagindo a processos ou fluxos de negócio como por exemplo o envio de email a um cliente após o seu cadastro.

EventBus

EventBus é um objeto registrado como singleton no TNF que é compartilhado na aplicação para que seja usado para manipular e controlar os eventos.

EventHandler e EventData

Para utilizar o EventBus é necessário fazer a injeção da dependência na classe onde o evento precisa ser disparado e fazer a implementação que irá conter a logica de execução deste evento (Handler).

NewRegistrationHandler
using Castle.Core.Logging;
using Tnf.Architecture.Domain.Interfaces.Services;
using Tnf.Dependency;
using Tnf.Events.Bus;
using Tnf.Events.Bus.Handlers;

namespace Tnf.Architecture.Domain.Events
{
    public class NewRegistrationHandler : IEventHandler<NewRegistrationEventData>, ITransientDependency
    {
        private readonly ILogger _logger;

        public NewRegistrationHandler(ILogger logger) => _logger = logger;

        public void HandleEvent(NewRegistrationEventData eventData)
        {
            _logger.Info("Registration event triggered");
        }
    }

    public class NewRegistrationEventData : EventData
    {
        public PersonDto Person { get; }

        public NewRegistrationEventData(PersonDto person)
        {
            Person = person;
        }
    }
}

O exemplo acima define a criação da estrutura do Evento (classe NewRegistrationEventData) e o Handler que irá ser disparado (NewRegistrationHandler).

Trigger Events

Na classe abaixo o evento é disparado dentro do serviço de domínio onde é feita a injeção do EventBus:

RegistrationService.cs
using Tnf.Architecture.Domain.Events;
using Tnf.Architecture.Domain.Interfaces.Services;
using Tnf.Domain.Services;
using Tnf.Dto;
using Tnf.Events.Bus;

namespace Tnf.Architecture.Domain.Registration
{
    public class RegistrationService : DomainService<IPersonRepository>, IRegistrationService
    {
        private readonly IEventBus _eventBus;
        public RegistrationService(IPersonRepository repository, IEventBus eventBus)
            : base(repository)
        {
            _eventBus = eventBus;
        }

        public DtoResponseBase<PersonDto> Register(PersonDto dto)
        {
            var response = new DtoResponseBase<PersonDto>();
            var builder = new PersonBuilder()
                   .WithName(dto.Name);

            var build = builder.Build();
            if (!build.Success)
            {
                response.AddNotifications(build.Notifications);
                return response;
            }

            var id = Repository.CreatePerson(dto);
            dto.Id = id;

            // Trigger event before create person
            _eventBus.Trigger(new NewRegistrationEventData(dto));
            return response;
        }
    }
}



  • Sem rótulos