一个领域事件可以理解为是发生在一个特定领域中的事件，是你希望在同一个领域中其他部分知道并产生后续动作的事件。一个领域事件必须对业务有价值，有助于形成完整的业务闭环，也即一个领域事件将导致进一步的业务操作。就比如我们今天说到的领域通知，就应该是一个事件，我们从命令中产生的错误提示，通过处理程序，引发到事件总线内，并返回到前台。

3、为什么需要领域事件

领域事件也是一种基于事件的架构（EDA）。事件架构的好处可以把处理的流程解耦，实现系统可扩展性，提高主业务流程的内聚性。

在咱们文章的开头，可说到了这个问题，不知道大家是否还记得，咱们再分析一下：

我们提交了一个添加Student 的申请，系统在完成保存后，可能还需要发送一个通知（当然这里错误信息，也有成功的），当然肯定还会会一些其他的后台服务的活动。如果把这一系列的动作放入一个处理过程中，会产生几个的明显问题：

1、一个是命令提交的的事务比较长，性能会有问题，甚至在极端情况下容易引发数据库的严重故障（服务器方面）；

2、另外提交的服务内聚性差，可维护性差，在业务流程发生变更时候，需要频繁修改主程序（程序员方面）。

3、我们有时候只关心核心的流程，就比如添加Student，我们只关心是否添加成功，而且我们需要对这个成功有反馈，但是发邮件的功能，我们却不用放在主业务中，甚至发送成功与否，不影响 Student 的正常添加，这样我们就把后续的这些活动事件，从主业务中剥离开，实现了高内聚和低耦合（业务方面）。

这个时候，就用到之前我画的图了，中介者模式下，上半部的命令总线已经说完，今天说另一半事件总线：

当然这里也有一个网上的栗子，很不错：

namespace Christ3D.Domain.Core.Events

{

    /// <summary>

    /// 事件模型 抽象基类，继承 INotification

    /// 也就是说，拥有中介者模式中的 发布/订阅模式

    /// </summary>

    public abstract class Event : INotification

    {

        // 时间戳

        public DateTime Timestamp { get; private set; }

        // 每一个事件都是有状态的

        protected Event()

        {

            Timestamp = DateTime.Now;

        }

    }

}

namespace Christ3D.Domain.Core.Bus

{

    /// <summary>

    /// 中介处理程序接口

    /// 可以定义多个处理程序

    /// 是异步的

    /// </summary>

    public interface IMediatorHandler

    {

        /// <summary>

        /// 发送命令，将我们的命令模型发布到中介者模块

        /// </summary>

        /// <typeparam name="T"> 泛型 </typeparam>

        /// <param name="command"> 命令模型，比如RegisterStudentCommand </param>

        /// <returns></returns>

        Task SendCommand<T>(T command) where T : Command;

        /// <summary>

        /// 引发事件，通过总线，发布事件

        /// </summary>

        /// <typeparam name="T"> 泛型 继承 Event：INotification</typeparam>

        /// <param name="event"> 事件模型，比如StudentRegisteredEvent，</param>

        /// 请注意一个细节：这个命名方法和Command不一样，一个是RegisterStudentCommand注册学生命令之前,一个是StudentRegisteredEvent学生被注册事件之后

        /// <returns></returns>

        Task RaiseEvent<T>(T @event) where T : Event;

    }

}

 /// <summary>

 /// 引发事件的实现方法

 /// </summary>

 /// <typeparam name="T">泛型 继承 Event：INotification</typeparam>

 /// <param name="event">事件模型，比如StudentRegisteredEvent</param>

 /// <returns></returns>

 public Task RaiseEvent<T>(T @event) where T : Event

 {

     // MediatR中介者模式中的第二种方法，发布/订阅模式

     return _mediator.Publish(@event);

 }

namespace Christ3D.Domain.Events

{

    /// <summary>

    /// Student被添加后引发事件

    /// 继承事件基类标识

    /// </summary>

    public class StudentRegisteredEvent : Event

    {

        // 构造函数初始化，整体事件是一个值对象

        public StudentRegisteredEvent(Guid id, string name, string email, DateTime birthDate, string phone)

        {

            Id = id;

            Name = name;

            Email = email;

            BirthDate = birthDate;

            Phone = phone;

        }

        public Guid Id { get; set; }

        public string Name { get; private set; }

        public string Email { get; private set; }

        public DateTime BirthDate { get; private set; }

        public string Phone { get; private set; }

    }

}

namespace Christ3D.Domain.EventHandlers

{

    /// <summary>

    /// Student事件处理程序

    /// 继承INotificationHandler<T>，可以同时处理多个不同的事件模型

    /// </summary>

    public class StudentEventHandler :

        INotificationHandler<StudentRegisteredEvent>,

        INotificationHandler<StudentUpdatedEvent>,

        INotificationHandler<StudentRemovedEvent>

    {

        // 学习被注册成功后的事件处理方法

        public Task Handle(StudentRegisteredEvent message, CancellationToken cancellationToken)

        {

            // 恭喜您，注册成功，欢迎加入我们。

            return Task.CompletedTask;

        }

        // 学生被修改成功后的事件处理方法

        public Task Handle(StudentUpdatedEvent message, CancellationToken cancellationToken)

        {

            // 恭喜您，更新成功，请牢记修改后的信息。

            return Task.CompletedTask;

        }

        // 学习被删除后的事件处理方法

        public Task Handle(StudentRemovedEvent message, CancellationToken cancellationToken)

        {

            // 您已经删除成功啦，记得以后常来看看。

            return Task.CompletedTask;

        }

    }

}

 // 持久化

 _studentRepository.Add(customer);

 // 统一提交

 if (Commit())

 {

     // 提交成功后，这里需要发布领域事件

     // 比如欢迎用户注册邮件呀，短信呀等

     Bus.RaiseEvent(new StudentRegisteredEvent(customer.Id, customer.Name, customer.Email, customer.BirthDate,customer.Phone));

 }

 // Domain - Events

 // 将事件模型和事件处理程序匹配注入

 services.AddScoped<INotificationHandler<StudentRegisteredEvent>, StudentEventHandler>();

 services.AddScoped<INotificationHandler<StudentUpdatedEvent>, StudentEventHandler>();

 services.AddScoped<INotificationHandler<StudentRemovedEvent>, StudentEventHandler>();

namespace Christ3D.Domain.Core.Notifications

{

    /// <summary>

    /// 领域通知模型，用来获取当前总线中出现的通知信息

    /// 继承自领域事件和 INotification（也就意味着可以拥有中介的发布/订阅模式）

    /// </summary>

    public class DomainNotification : Event

    {

        // 标识

        public Guid DomainNotificationId { get; private set; }

        // 键（可以根据这个key，获取当前key下的全部通知信息）

        // 这个我们在事件源和事件回溯的时候会用到，伏笔

        public string Key { get; private set; }

        // 值（与key对应）

        public string Value { get; private set; }

        // 版本信息

        public int Version { get; private set; }

        public DomainNotification(string key, string value)

        {

            DomainNotificationId = Guid.NewGuid();

            Version = ;

            Key = key;

            Value = value;

        }

    }

}

namespace Christ3D.Domain.Core.Notifications

{

    /// <summary>

    /// 领域通知处理程序，把所有的通知信息放到事件总线中

    /// 继承 INotificationHandler<T>

    /// </summary>

    public class DomainNotificationHandler : INotificationHandler<DomainNotification>

    {

        // 通知信息列表

        private List<DomainNotification> _notifications;

        // 每次访问该处理程序的时候，实例化一个空集合

        public DomainNotificationHandler()

        {

            _notifications = new List<DomainNotification>();

        }

        // 处理方法，把全部的通知信息，添加到内存里

        public Task Handle(DomainNotification message, CancellationToken cancellationToken)

        {

            _notifications.Add(message);

            return Task.CompletedTask;

        }

        // 获取当前生命周期内的全部通知信息

        public virtual List<DomainNotification> GetNotifications()

        {

            return _notifications;

        }

        // 判断在当前总线对象周期中，是否存在通知信息

        public virtual bool HasNotifications()

        {

            return GetNotifications().Any();

        }

        // 手动回收（清空通知）

        public void Dispose()

        {

            _notifications = new List<DomainNotification>();

        }

    }

}

 // 判断邮箱是否存在

 // 这些业务逻辑，当然要在领域层中（领域命令处理程序中）进行处理

 if (_studentRepository.GetByEmail(customer.Email) != null)

 {

     ////这里对错误信息进行发布，目前采用缓存形式

     //List<string> errorInfo = new List<string>() { "该邮箱已经被使用！" };

     //Cache.Set("ErrorData", errorInfo);

     //引发错误事件

     Bus.RaiseEvent(new DomainNotification("", "该邮箱已经被使用！"));

     return Task.FromResult(new Unit());

 }

 //将领域命令中的验证错误信息收集

 //目前用的是缓存方法（以后通过领域通知替换）

 protected void NotifyValidationErrors(Command message)

 {

     List<string> errorInfo = new List<string>();

     foreach (var error in message.ValidationResult.Errors)

     {

         //errorInfo.Add(error.ErrorMessage);

         //将错误信息提交到事件总线，派发出去

         _bus.RaiseEvent(new DomainNotification("", error.ErrorMessage));

     }

     //将错误信息收集一：缓存方法（错误示范）

     //_cache.Set("ErrorData", errorInfo);

 }

    public class AlertsViewComponent : ViewComponent

    {

        // 缓存注入，为了收录信息（错误方法，以后会用通知，通过领域事件来替换）

        // private IMemoryCache _cache;

        // 领域通知处理程序

        private readonly DomainNotificationHandler _notifications;

        // 构造函数注入

        public AlertsViewComponent(INotificationHandler<DomainNotification> notifications)

        {

            _notifications = (DomainNotificationHandler)notifications;

        }

        /// <summary>

        /// Alerts 视图组件

        /// 可以异步，也可以同步，注意方法名称，同步的时候是Invoke

        /// 我写异步是为了为以后做准备

        /// </summary>

        /// <returns></returns>

        public async Task<IViewComponentResult> InvokeAsync()

        {

            // 从通知处理程序中，获取全部通知信息，并返回给前台

            var notificacoes = await Task.FromResult((_notifications.GetNotifications()));

            notificacoes.ForEach(c => ViewData.ModelState.AddModelError(string.Empty, c.Value));

            return View();

        }

    }

 // 将事件模型和事件处理程序匹配注入

 services.AddScoped<INotificationHandler<DomainNotification>, DomainNotificationHandler>();