• C#中的事件聚合器实现方法

    概述：_对象之间的关系_是使代码库难以理解和难以维护的原因。为了更好地理解它，我们求助于马丁·福勒（Martin Fowler）：事件聚合器是间接的简单元素。在最简单的形式中，您可以让它注册到您感兴趣的所有源对象，并让所有目标对象注册到事件聚合器。事件聚合器通过将源对象中的任何事件传播到目标对象来响应该事件。事件聚合器有很多好处。在本文中，我将展示事件聚合器如何使我们更容易扩展应用程序。给我一个理由！为了展示它如何使我们的代码更易于理解，请查看以下模型：public class User { public string Id { get; set; } public bool IsMarried_对象之间的关系_是使代码库难以理解和难以维护的原因。

    想了解更多游戏开发知识,可以扫描下方二维码,免费领取游戏开发4天训练营课程

    为了更好地理解它，我们求助于马丁·福勒（Martin Fowler）：

    图片

    事件聚合器是间接的简单元素。在最简单的形式中，您可以让它注册到您感兴趣的所有源对象，并让所有目标对象注册到事件聚合器。事件聚合器通过将源对象中的任何事件传播到目标对象来响应该事件。

    事件聚合器有很多好处。在本文中，我将展示事件聚合器如何使我们更容易扩展应用程序。

    给我一个理由！

    为了展示它如何使我们的代码更易于理解，请查看以下模型：

    1. public class User {
    2.   public string Id { get; set; }
    3.   public bool IsMarried { get; set; }
    4. }
    5. public class Resume {
    6.   public string Description { get; set; }
    7.   public string UserId { get; set; }
    8.   public bool IsUserMarried { get; set; }
    9. }
    10. public class Store {
    11.   public string Title { get; set; }
    12.   public string OwnerId { get; set; }
    13.   public bool IsOwnerMarried { get; set; }
    14. }

    在这里，并将用户的当前婚姻状况存储在一个名为 的字段中。假设每个实体都是一个聚合根，因此每个实体都有自己的服务：ResumeStoreIsUserMarried

    1. public class ResumeService {
    2.   private readonly ICollection<Resume> db = new List<Resume> {
    3.     new Resume {
    4.       Description = "My current resume",
    5.       UserId = "1",
    6.       IsUserMarried = false
    7.     }
    8.   };
    9.   public void SetMaritalStatus(string userId, bool isMarried) {
    10.     foreach (var resume in db.Where(a => a.UserId.Equals(userId))) {
    11.       resume.IsUserMarried = isMarried;
    12.     }
    13.   }
    14. }
    15. public class StoreService {
    16.   private readonly ICollection<Store> db = new List<Store> {
    17.     new Store {
    18.       Title = "Restaurant",
    19.       OwnerId = "1",
    20.       IsOwnerMarried = false
    21.     }
    22.   };
    23.   public void SetMaritalStatus(string ownerId, bool isMarried) {
    24.     foreach (var store in db.Where(a => a.OwnerId.Equals(ownerId))) {
    25.       store.IsOwnerMarried = isMarried;
    26.     }
    27.   }
    28. }
    29. public class UserService {
    30.   private readonly ICollection<User> db = new List<User> {
    31.     new User {
    32.       Id = "1",
    33.       IsMarried = false
    34.     }
    35.   };
    36.   private readonly ResumeService resumeService;
    37.   private readonly StoreService storeService;
    38.   
    39.   public UserService(ResumeService resumeService, 
    40.     StoreService storeService) {
    41.     this.resumeService = resumeService;
    42.     this.storeService = storeService;
    43.   }
    44.   public void GotMarried(string userId) {
    45.     var user = db.First(a => a.Id.Equals(userId));
    46.     user.IsMarried = true;
    47.   
    48.     // propagate changes to other parts of the code
    49.     resumeService.SetMaritalStatus(userId, true);
    50.     storeService.SetMaritalStatus(userId, true);
    51.   }
    52. }

    ResumeService并且两者都有一个更新用户婚姻状况的方法（ ）。正如你所看到的，对这两个服务都有依赖性，因为当一个用户结婚时，想要通知其他服务。此代码有效，但有两个缺点：StoreServiceSetMaritalStatusUserServiceUserService

    1-实际上不依赖或执行其操作！=>（假依赖关系）UserServiceResumeServiceStoreService

    2-每当我们添加存储用户婚姻状况的新实体时，我们必须记住更新！=>（难以扩展）GotMarriedUserService

    解决方案：事件聚合器

    与其引入依赖项（其他服务），不如调整定义一个事件：UserService

    1. public class MaritalStatusChanged : IEvent {  
    2.   public MaritalStatusChanged(string userId, bool isMarried) {  
    3.     UserId = userId;  
    4.     IsMarried = isMarried;  
    5.   }  
    6.   public string UserId { get; }  
    7.   public bool IsMarried { get; }  
    8. }

    然后我们需要更新.首先删除依赖项，然后更新方法：UserServiceGotMarried

    1. public class UserService {  
    2.   private readonly ICollection<User> db = new List<User> {  
    3.     new User {  
    4.       Id = "1",  
    5.       IsMarried = false  
    6.     }  
    7.   };  
    8.   private readonly IEventEmitter eventEmitter
    9.   public UserService(IEventEmitter eventEmitter) {  
    10.     this.eventEmitter = eventEmitter;  
    11.   }  
    12.   public void GotMarried(string userId) {  
    13.     var user = db.First(a => a.Id.Equals(userId));  
    14.     user.IsMarried = true;  
    15.     
    16.     // propagate changes to other parts of the code  
    17.      eventEmitter.Publish(new MaritalStatusChanged(userId, true)); 
    18.   }  
    19. }

    所以现在，它只取决于事件发射器。活动发射器是我们的活动总线！它在整个域中发布事件。现在，如果想要了解此事件，我们只需创建一个处理程序。例如，这是一个添加到正文中的处理程序：ResumeService

    1. public class MaritalStatusChangedHandler :  
    2.  IEventHandler<MaritalStatusChanged> {  
    3.   private readonly ResumeService service;  
    4.   public MaritalStatusChangedHandler(ResumeService service) {  
    5.     this.service = service;  
    6.   }  
    7.   public Task Handle(MaritalStatusChanged ev) {  
    8.     service.SetMaritalStatus(ev.UserId, ev.IsMarried); 
    9.     return Task.CompletedTask;  
    10.   }  
    11. }

    将它们粘在一起：

    1. // 1- create an event bus
    2. var bus = new DefaultEventBus();
    3. // 2- create services
    4. var userService = new UserService(bus);
    5. var resumeService = new ResumeService();
    6. var storeService = new StoreService();
    7. // 3- subscribe
    8. bus.Subscribe<MaritalStatusChanged, ResumeService.MaritalStatusChangedHandler>(
    9.   new ResumeService.MaritalStatusChangedHandler(resumeService));
    10. bus.Subscribe<MaritalStatusChanged, StoreService.MaritalStatusChangedHandler>(
    11.   new StoreService.MaritalStatusChangedHandler(storeService));
    12. // 4- someone got married
    13. userService.GotMarried("1");

    1- 这将创建事件总线。事件总线实现 IEventEmitter 和 IEventSink。 发布事件并允许您订阅事件。

    完整代码：

    1. using libc.eventbus.System;
    2. using libc.eventbus.Types;
    3. using Microsoft.VisualStudio.TestTools.UnitTesting;
    4. using System;
    5. using System.Collections.Generic;
    6. using System.Linq;
    7. using System.Threading.Tasks;
    8.  
    9. namespace libc.eventbus.tests
    10. {
    11.   [TestClass]
    12.   public class Showcase2
    13.   {
    14.     [TestMethod]
    15.     public void Showcase()
    16.     {
    17.       // 1- create an event bus
    18.       var bus = new DefaultEventBus();
    19.  
    20.       // 2- create services
    21.       var userService = new UserService(bus);
    22.       var resumeService = new ResumeService();
    23.       var storeService = new StoreService();
    24.  
    25.       // 3- subscribe
    26.       bus.Subscribe<MaritalStatusChanged, ResumeService.MaritalStatusChangedHandler>(
    27.           new ResumeService.MaritalStatusChangedHandler(resumeService));
    28.  
    29.       bus.Subscribe<MaritalStatusChanged, StoreService.MaritalStatusChangedHandler>(
    30.           new StoreService.MaritalStatusChangedHandler(storeService));
    31.  
    32.       // 4- someone got married
    33.       userService.GotMarried("1");
    34.     }
    35.  
    36.     public class UserService
    37.     {
    38.       private readonly ICollection<User> _db = new List<User>
    39.             {
    40.                 new User
    41.                 {
    42.                     Id = "1",
    43.                     IsMarried = false
    44.                 }
    45.             };
    46.  
    47.       private readonly IEventEmitter _eventEmitter;
    48.  
    49.       public UserService(IEventEmitter eventEmitter)
    50.       {
    51.         _eventEmitter = eventEmitter;
    52.       }
    53.  
    54.       public void GotMarried(string userId)
    55.       {
    56.         var user = _db.First(a => a.Id.Equals(userId));
    57.         user.IsMarried = true;
    58.  
    59.         // propagate changes to other parts of the code
    60.         _eventEmitter.Publish(new MaritalStatusChanged(userId, true));
    61.       }
    62.     }
    63.  
    64.     public class ResumeService
    65.     {
    66.       private readonly ICollection<Resume> _db = new List<Resume>
    67.             {
    68.                 new Resume
    69.                 {
    70.                     Description = "My current resume",
    71.                     UserId = "1",
    72.                     IsUserMarried = false
    73.                 }
    74.             };
    75.  
    76.       public void SetMaritalStatus(string userId, bool isMarried)
    77.       {
    78.         foreach (var resume in _db.Where(a => a.UserId.Equals(userId))) resume.IsUserMarried = isMarried;
    79.  
    80.         Console.WriteLine($"{userId} is {(isMarried ? "married" : "single")} now");
    81.       }
    82.  
    83.       public class MaritalStatusChangedHandler : IEventHandler<MaritalStatusChanged>
    84.       {
    85.         private readonly ResumeService _service;
    86.  
    87.         public MaritalStatusChangedHandler(ResumeService service)
    88.         {
    89.           _service = service;
    90.         }
    91.  
    92.         public Task Handle(MaritalStatusChanged ev)
    93.         {
    94.           _service.SetMaritalStatus(ev.UserId, ev.IsMarried);
    95.  
    96.           return Task.CompletedTask;
    97.         }
    98.       }
    99.     }
    100.  
    101.     public class StoreService
    102.     {
    103.       private readonly ICollection<Store> _db = new List<Store>
    104.             {
    105.                 new Store
    106.                 {
    107.                     Title = "Restaurant",
    108.                     OwnerId = "1",
    109.                     IsOwnerMarried = false
    110.                 }
    111.             };
    112.  
    113.       public void SetMaritalStatus(string userId, bool isMarried)
    114.       {
    115.         foreach (var store in _db.Where(a => a.OwnerId.Equals(userId))) store.IsOwnerMarried = isMarried;
    116.  
    117.         Console.WriteLine($"{userId} is {(isMarried ? "married" : "single")} now");
    118.       }
    119.  
    120.       public class MaritalStatusChangedHandler : IEventHandler<MaritalStatusChanged>
    121.       {
    122.         private readonly StoreService _service;
    123.  
    124.         public MaritalStatusChangedHandler(StoreService service)
    125.         {
    126.           _service = service;
    127.         }
    128.  
    129.         public Task Handle(MaritalStatusChanged ev)
    130.         {
    131.           _service.SetMaritalStatus(ev.UserId, ev.IsMarried);
    132.  
    133.           return Task.CompletedTask;
    134.         }
    135.       }
    136.     }
    137.  
    138.     public class MaritalStatusChanged : IEvent
    139.     {
    140.       public MaritalStatusChanged(string userId, bool isMarried)
    141.       {
    142.         UserId = userId;
    143.         IsMarried = isMarried;
    144.       }
    145.  
    146.       public string UserId { get; }
    147.       public bool IsMarried { get; }
    148.     }
    149.  
    150.     public class User
    151.     {
    152.       public string Id { get; set; }
    153.       public bool IsMarried { get; set; }
    154.     }
    155.  
    156.     public class Resume
    157.     {
    158.       public string Description { get; set; }
    159.       public string UserId { get; set; }
    160.       public bool IsUserMarried { get; set; }
    161.     }
    162.  
    163.     public class Store
    164.     {
    165.       public string Title { get; set; }
    166.       public string OwnerId { get; set; }
    167.       public bool IsOwnerMarried { get; set; }
    168.     }
    169.   }
    170. }
  • 相关阅读:
    Llama3 中文通用 Agent 微调模型来啦！（附手把手微调实战教程）
    《使用Gin框架构建分布式应用》阅读笔记：p52-p76
    CentOS7.x部署GreenPlum6.x
    vue.js实例选项
    【MySQL】增删改查进阶
    高级开发要会高效Java
    面试2：通用能力
    [认知能力]电子信息类专业新生暑假可以先预习一些什么专业内容？
    springboot+zookeepr+dubbo的远程服务调用
    10.07hw
  • 原文地址：https://blog.csdn.net/2401_82584055/article/details/139274567