C#实现发布订阅模式

最新推荐文章于 2023-12-27 01:00:05 发布
最新推荐文章于 2023-12-27 01:00:05 发布
阅读量781 收藏 1
点赞数 2
文章标签： c# 测试

首先给出项目的结构

 

IPublish.cs的源码：

 1 namespace NsWebChat.PublishSubscribe
 2 {
 3     /// <summary>
 4     /// 发布事件基础接口
 5     /// </summary>
 6     public interface IPublish
 7     {
 8         string PublishTag { get; set; }
 9         object PublishData { get; set; }
10     }
11 }

 

IPubSubCenter.cs的源码：

 1 namespace NsWebChat.PublishSubscribe
 2 {
 3     /// <summary>
 4     /// 订阅发布中心基础接口
 5     /// </summary>
 6     public interface IPubSubCenter
 7     {
 8         /// <summary>
 9         /// 订阅事件
10         /// </summary>
11         bool AddSubscribe(string tag, Func<ISubscribe, object, object> method, object data, string name);
12         bool AddSubscribe(string tag, Func<ISubscribe, object, object> method, string name);
13         bool AddSubscribe(Subscribe subscribe);
14         /// <summary>
15         /// 获得指定事件的订阅列表
16         /// </summary>
17         SubscribeList GetSubscribeList(string tag);
18         /// <summary>
19         /// 获得订阅
20         /// </summary>
21         Subscribe GetSubscribe(string tag, string name);
22         /// <summary>
23         /// 删除订阅
24         /// </summary>
25         void RemoveSubscribe(string tag, string name);
26 
27         /// <summary>
28         /// 发布事件
29         /// </summary>
30         IEnumerable<Object> Publish(string tag, object data);
31         IEnumerable<Object> Publish(string tag);
32         IEnumerable<Object> Publish(Publish publish);
33     }
34 }

 

ISubscribe.cs的源码：

 1 namespace NsWebChat.PublishSubscribe
 2 {
 3     /// <summary>
 4     /// 订阅事件基础接口
 5     /// </summary>
 6     public interface ISubscribe
 7     {
 8         /// <summary>
 9         /// 订阅的事件
10         /// </summary>
11         string SubscribeTag { get; set; }
12         /// <summary>
13         /// 订阅的名称
14         /// </summary>
15         string SubscribeName { get; set; }
16         /// <summary>
17         /// 响应发布时传递的参数
18         /// </summary>
19         object Data { get; set; }
20         /// <summary>
21         /// 响应发布的方法
22         /// </summary>
23         Func<ISubscribe, object, object> SubscribeMethod { get; set; }
24         /// <summary>
25         /// 调用订阅方法
26         /// </summary>
27         object Invoke(object val);
28     }
29 }

 

Publish.cs的源码：

 1 namespace NsWebChat.PublishSubscribe
 2 {
 3     /// <summary>
 4     /// 发布事件基类
 5     /// </summary>
 6     public class Publish : IPublish
 7     {
 8         private string _publishTag;
 9         private object _publishData;
10 
11         public Publish()
12         {
13         }
14 
15         public Publish(string tag)
16             : this(tag, new object())
17         {
18 
19         }
20 
21         public Publish(string tag, object val)
22         {
23             _publishTag = tag;
24             _publishData = val;
25         }
26 
27         public string PublishTag
28         {
29             get
30             {
31                 return _publishTag;
32             }
33             set
34             {
35                 _publishTag = value;
36             }
37         }
38 
39         public object PublishData
40         {
41             get
42             {
43                 return _publishData;
44             }
45             set
46             {
47                 _publishData = value;
48             }
49         }
50     }
51 }

 

PubSubCenter.cs的源码：

  1 namespace NsWebChat.PublishSubscribe
  2 {
  3     /// <summary>
  4     /// 订阅发布中心基类
  5     /// </summary>
  6     public class PubSubCenter : IPubSubCenter
  7 
  8     {
  9         private Dictionary<string, SubscribeList> _pubsubList = new Dictionary<string, SubscribeList>();
 10 
 11         public bool AddSubscribe(string tag, Func<ISubscribe, object, object> method, object data ,string name)
 12         {
 13             Subscribe subscribe = new Subscribe();
 14             subscribe.Data = data;
 15             subscribe.SubscribeMethod = method;
 16             subscribe.SubscribeTag = tag;
 17             subscribe.SubscribeName = name;
 18             return AddSubscribe(subscribe);
 19         }
 20 
 21         public bool AddSubscribe(string tag, Func<ISubscribe, object, object> method, string name)
 22         {
 23             return AddSubscribe(tag, method, new object(),name);
 24         }
 25 
 26         public bool AddSubscribe(Subscribe subscribe)
 27         {
 28             if (subscribe == null)
 29             {
 30                 return false;
 31             }
 32             else
 33             {
 34                 if (String.IsNullOrEmpty(subscribe.SubscribeName))
 35                 {
 36                     return false;
 37                 }
 38                 Subscribe subscribet = GetSubscribe(subscribe.SubscribeTag, subscribe.SubscribeName);
 39                 if (subscribet != null)
 40                 {
 41                     return false;
 42                 }
 43                 else
 44                 {
 45                     if (_pubsubList.ContainsKey(subscribe.SubscribeTag))
 46                     {
 47                         _pubsubList[subscribe.SubscribeTag].Add(subscribe);
 48                     }
 49                     else
 50                     {
 51                         SubscribeList list = new SubscribeList();
 52                         list.Add(subscribe);
 53                         _pubsubList.Add(subscribe.SubscribeTag, list);
 54                     }
 55                     return true;
 56                 }
 57             }
 58         }
 59 
 60         public SubscribeList GetSubscribeList(string tag)
 61         {
 62             if (_pubsubList.ContainsKey(tag))
 63             {
 64                 return _pubsubList[tag];
 65             }
 66             else
 67             {
 68                 return new SubscribeList();
 69             }
 70         }
 71 
 72         public Subscribe GetSubscribe(string tag, string name)
 73         {
 74             if (_pubsubList.ContainsKey(tag))
 75             {
 76                 foreach (Subscribe item in _pubsubList[tag])
 77                 {
 78                     if (item.SubscribeName == name)
 79                     {
 80                         return item;
 81                     }
 82                 }
 83                 return null;
 84             }
 85             else
 86             {
 87                 return null;
 88             }
 89         }
 90 
 91         public void RemoveSubscribe(string tag, string name)
 92         {
 93             Subscribe subscribe = GetSubscribe(tag, name);
 94             _pubsubList[tag].Remove(subscribe);
 95         }
 96 
 97         public IEnumerable<object> Publish(string tag, object data)
 98         {
 99             if (_pubsubList.ContainsKey(tag))
100             {
101                 foreach (Subscribe item in _pubsubList[tag])
102                 {
103                     yield return item.Invoke(data);
104                 }
105             }
106             else
107             {
108                 yield break;
109             }
110         }
111 
112         public IEnumerable<object> Publish(string tag)
113         {
114             return Publish(tag, new object());
115         }
116 
117         public IEnumerable<object> Publish(Publish publish)
118         {
119             return Publish(publish.PublishTag, publish.PublishData);
120         }
121     }
122 }

 

Subscribe.cs源码：

 

 1 namespace NsWebChat.PublishSubscribe
 2 {
 3     /// <summary>
 4     /// 订阅事件基类
 5     /// </summary>
 6     public class Subscribe : ISubscribe
 7     {
 8         private object _data;
 9         private Func<ISubscribe, object, object> _subscribeMethod;
10         private string _subscribeTag;
11         private string _subscribeName;
12 
13         public Subscribe()
14         {
15         }
16 
17         public Subscribe(string tag, Func<ISubscribe, object, object> method)
18             : this(tag, method, "")
19         {
20 
21         }
22 
23         public Subscribe(string tag, Func<ISubscribe, object, object> method, object data)
24             : this(tag, method, data, "")
25         {
26 
27         }
28 
29         public Subscribe(string tag, Func<ISubscribe, object, object> method,string name)
30             : this(tag, method, new object(), name)
31         {
32 
33         }
34 
35         public Subscribe(string tag, Func<ISubscribe, object, object> method, object data,string name)
36         {
37             _data = data;
38             _subscribeTag = tag;
39             _subscribeMethod = method;
40             _subscribeName = name;
41         }
42 
43         public object Data
44         {
45             get
46             {
47                 return _data;
48             }
49             set
50             {
51                 _data = value;
52             }
53         }
54 
55         public Func<ISubscribe, object, object> SubscribeMethod
56         {
57             get
58             {
59                 return _subscribeMethod;
60             }
61             set
62             {
63                 _subscribeMethod = value;
64             }
65         }
66 
67         public object Invoke(object val)
68         {
69             return SubscribeMethod(this, val);
70         }
71 
72         public string SubscribeTag
73         {
74             get
75             {
76                 return _subscribeTag;
77             }
78             set
79             {
80                 _subscribeTag = value;
81             }
82         }
83 
84         public string SubscribeName
85         {
86             get
87             {
88                 return _subscribeName;
89             }
90             set
91             {
92                 _subscribeName = value;
93             }
94         }
95     }
96 }

 

SubscribeList.cs的源码：

 1 namespace NsWebChat.PublishSubscribe
 2 {
 3     /// <summary>
 4     /// 订阅列表
 5     /// </summary>
 6     public class SubscribeList : IList<Subscribe>
 7     {
 8         private List<Subscribe> subscribes = new List<Subscribe>();
 9 
10         public int IndexOf(Subscribe item)
11         {
12             return subscribes.IndexOf(item);
13         }
14 
15         public void Insert(int index, Subscribe item)
16         {
17             subscribes.Insert(index, item);
18         }
19 
20         public void RemoveAt(int index)
21         {
22             subscribes.RemoveAt(index);
23         }
24 
25         public Subscribe this[int index]
26         {
27             get
28             {
29                 return subscribes[index];
30             }
31             set
32             {
33                 subscribes[index] = value;
34             }
35         }
36 
37         public void Add(Subscribe item)
38         {
39             subscribes.Add(item);
40         }
41 
42         public void Clear()
43         {
44             subscribes.Clear();
45         }
46 
47         public bool Contains(Subscribe item)
48         {
49             return subscribes.Contains(item);
50         }
51 
52         public void CopyTo(Subscribe[] array, int arrayIndex)
53         {
54             subscribes.CopyTo(array, arrayIndex);
55         }
56 
57         public int Count
58         {
59             get
60             {
61                 return subscribes.Count;
62             }
63         }
64 
65         public bool IsReadOnly
66         {
67             get { return false; }
68         }
69 
70         public bool Remove(Subscribe item)
71         {
72             return subscribes.Remove(item);
73         }
74 
75         public IEnumerator<Subscribe> GetEnumerator()
76         {
77             return subscribes.GetEnumerator();
78         }
79 
80         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
81         {
82             return subscribes.GetEnumerator();
83         }
84     }
85 }

 

下面是单元测试的源码（PubSubCenterTest.cs）：

  1 namespace WebChatUnitTest
  2 {
  3     [TestClass]
  4     public class PubSubCenterTest
  5     {
  6         public object Test1(ISubscribe subscribe, object data)
  7         {
  8             Assert.IsTrue(subscribe.Data == data);
  9             return data;
 10         }
 11 
 12         public object Test2(ISubscribe s, object d)
 13         {
 14             return d;
 15         }
 16 
 17         public object Test3(ISubscribe s, object d)
 18         {
 19             return d;
 20         }
 21 
 22         public object Test4(ISubscribe s, object d)
 23         {
 24             return d;
 25         }
 26 
 27         public object Test5(ISubscribe s, object d)
 28         {
 29             return s.SubscribeName;
 30         }
 31 
 32         //测试删除订阅
 33         [TestMethod]
 34         public void TestRemoveSubscribe()
 35         {
 36             PubSubCenter pbc = new PubSubCenter();
 37             pbc.AddSubscribe("t1", Test5, "1");
 38             pbc.AddSubscribe("t1", Test5, "2");
 39             pbc.RemoveSubscribe("t1", "2");
 40             List<string> al = new List<string>();
 41             foreach (string item in pbc.Publish("t1"))
 42             {
 43                 al.Add(item);
 44             }
 45             Assert.IsTrue(al.Count == 1);
 46             Assert.IsTrue(al[0] == "1");
 47             pbc.AddSubscribe("t1", Test5, "2");
 48             pbc.RemoveSubscribe("t1", "1");
 49             al.Clear();
 50             foreach (string item in pbc.Publish("t1"))
 51             {
 52                 al.Add(item);
 53             }
 54             Assert.IsTrue(al.Count == 1);
 55             Assert.IsTrue(al[0] == "2");
 56         }
 57 
 58         //测试重载版本的订阅发布
 59         [TestMethod]
 60         public void TestMoreSubscribeAndPublish()
 61         {
 62             PubSubCenter pbc = new PubSubCenter();
 63             Subscribe subscribe = new Subscribe("t1", Test2, "2", "1");
 64             Subscribe subscribe2 = new Subscribe("t1", Test2, "2");
 65             Subscribe subscribe3 = new Subscribe();
 66             subscribe3.SubscribeMethod = Test2;
 67             subscribe3.SubscribeName = "3";
 68             subscribe3.SubscribeTag = "t1";
 69             pbc.AddSubscribe(subscribe);
 70             pbc.AddSubscribe(subscribe2);
 71             pbc.AddSubscribe(subscribe3);
 72             pbc.AddSubscribe("t1", Test2, "4");
 73             pbc.AddSubscribe("t1", Test2, "2", "5");
 74             List<object> al = new List<object>();
 75             foreach (object item in pbc.Publish("t1"))
 76             {
 77                 al.Add(item);
 78             }
 79             Assert.IsTrue(al.Count == 5);
 80             Assert.IsNotNull(al[0]);
 81             Assert.IsNotNull(al[1]);
 82             Assert.IsNotNull(al[2]);
 83             Assert.IsNotNull(al[3]);
 84             Assert.IsNotNull(al[4]);
 85             al.Clear();
 86             foreach (object item in pbc.Publish("t1","2"))
 87             {
 88                 al.Add(item);
 89             }
 90             Assert.IsTrue(al.Count == 5);
 91             Assert.IsNotNull(al[0]);
 92             Assert.IsNotNull(al[1]);
 93             Assert.IsNotNull(al[2]);
 94             Assert.IsNotNull(al[3]);
 95             Assert.IsNotNull(al[4]);
 96 
 97             Publish pub = new Publish("t1");
 98             al.Clear();
 99             foreach (object item in pbc.Publish(pub))
100             {
101                 al.Add(item);
102             }
103             Assert.IsTrue(al.Count == 5);
104             Assert.IsNotNull(al[0]);
105             Assert.IsNotNull(al[1]);
106             Assert.IsNotNull(al[2]);
107             Assert.IsNotNull(al[3]);
108             Assert.IsNotNull(al[4]);
109 
110             pub = new Publish("t1", "2");
111             al.Clear();
112             foreach (object item in pbc.Publish(pub))
113             {
114                 al.Add(item);
115             }
116             Assert.IsTrue(al.Count == 5);
117             Assert.IsNotNull(al[0]);
118             Assert.IsNotNull(al[1]);
119             Assert.IsNotNull(al[2]);
120             Assert.IsNotNull(al[3]);
121             Assert.IsNotNull(al[4]);
122 
123             pub = new Publish();
124             pub.PublishData = "2";
125             pub.PublishTag = "t1";
126             al.Clear();
127             foreach (object item in pbc.Publish(pub))
128             {
129                 al.Add(item);
130             }
131             Assert.IsTrue(al.Count == 5);
132             Assert.IsNotNull(al[0]);
133             Assert.IsNotNull(al[1]);
134             Assert.IsNotNull(al[2]);
135             Assert.IsNotNull(al[3]);
136             Assert.IsNotNull(al[4]);
137         }
138 
139         //测试重名订阅事件
140         [TestMethod]
141         public void TestSameNameSubscribe()
142         {
143             PubSubCenter pbc = new PubSubCenter();
144             pbc.AddSubscribe("t1", Test2, "2");
145             pbc.AddSubscribe("t1", Test2, "2");
146             pbc.AddSubscribe("t1", Test2, "3");
147             List<string> al = new List<string>();
148             foreach (string item in pbc.Publish("t1", "123"))
149             {
150                 al.Add(item);
151             }
152             Assert.IsTrue(al.Count == 2);
153             Assert.IsTrue(al[0] == "123");
154             Assert.IsTrue(al[1] == "123");
155         }
156 
157         //测试多方法订阅单事件
158         [TestMethod]
159         public void TestMoreSubscribeToOnePublish()
160         {
161             PubSubCenter pbc = new PubSubCenter();
162             pbc.AddSubscribe("t1", Test2, "1");
163             pbc.AddSubscribe("t1", Test3, "2");
164             pbc.AddSubscribe("t1", Test4, "3");
165             List<string> al = new List<string>();
166             foreach (string item in pbc.Publish("t1", "2"))
167             {
168                 al.Add(item);
169             }
170             Assert.IsTrue(al.Count == 3);
171             Assert.IsTrue(al[0] == "2");
172             Assert.IsTrue(al[1] == "2");
173             Assert.IsTrue(al[2] == "2");
174         }
175 
176         //测试单方法订阅多事件
177         [TestMethod]
178         public void TestOneSubscribeToMorePublish()
179         {
180             PubSubCenter pbc = new PubSubCenter();
181             pbc.AddSubscribe("t1", Test1, "2", "t1");
182             pbc.AddSubscribe("t2", Test1, "3", "t2");
183             pbc.AddSubscribe("t3", Test1, "4", "t3");
184             pbc.AddSubscribe("t4", Test1, "5", "t4");
185             IList<String> al = new List<String>();
186             foreach(String item in pbc.Publish("t1","2"))
187             {
188                 al.Add(item);
189             }
190             Assert.IsTrue(al.Count == 1);
191             Assert.IsTrue(al[0] == "2");
192             al.Clear();
193             foreach (String item in pbc.Publish("t2", "3"))
194             {
195                 al.Add(item);
196             }
197             Assert.IsTrue(al.Count == 1);
198             Assert.IsTrue(al[0] == "3");
199             al.Clear();
200             foreach (String item in pbc.Publish("t3", "4"))
201             {
202                 al.Add(item);
203             }
204             Assert.IsTrue(al.Count == 1);
205             Assert.IsTrue(al[0] == "4");
206             al.Clear();
207             foreach (String item in pbc.Publish("t4", "5"))
208             {
209                 al.Add(item);
210             }
211             Assert.IsTrue(al.Count == 1);
212             Assert.IsTrue(al[0] == "5");
213         }
214     }
215 }

 

weixin_33735077
关注
C#中的事件——发布者订阅者模式
weixin_66598341的博客
03-28 2783
简单介绍了事件的发布者/订阅者模式，以及如何使用系统提供的处理事件的标准委托类型EventHandler。
C#中事件委托订阅发布模式
08-15
C#,事件，委托，订阅-发布
C#订阅与发布标准实现
anfeng4628的博客
12-14 153
大概看了下C#官方提供的IObservable接口以及IObserver接口来实现发布和订阅，写的很标准，很有代表性，做下笔记，以后要是项目需要用到发布订阅再基于自己的需求改： public class BaggageInfo { private int flightNo; private string origin; private int loca...
SpringBoot事件监听机制及观察者模式/发布订阅模式
天乔巴夏丶
12-21 1758
文章目录本篇要点什么是观察者模式？发布订阅模式是什么？Spring事件监听机制概述SpringBoot事件监听定义注册事件注解方式 @EventListener定义监听器实现ApplicationListener的方式定义监听器注册事件发布者定义接口主程序类测试接口源码下载参考阅读 本篇要点 介绍观察者模式和发布订阅模式的区别。 SpringBoot快速入门事件监听。 什么是观察者模式？ 观察者模式是经典行为型设计模式之一。 在GoF的《设计模式》中，观察者模式的定义：在对象之间定义一个一对多的依赖，当
C#中的事件-订阅与发布
weixin_30517001的博客
08-03 284
　　我们用一个简单的例子，来说明一下这种消息传递的机制。 　　有一家三口，妈妈负责做饭，爸爸和孩子负责吃。。。将这三个人，想象成三个类。 　　妈妈有一个方法，叫做“做饭”。有一个事件，叫做“开饭”。做完饭后，调用开发事件，发布开饭消息。 　　爸爸和孩子分别有一个方法，叫做“吃饭”。 　　将爸爸和孩子的“吃饭”方法，注册到妈妈的“开饭”事件。也就是，订阅妈妈的开饭消息。让妈妈做完饭开饭时，发...
用C#实现的ActiveMQ发布/订阅消息传送
12-09
用C#实现的ActiveMQ发布/订阅消息传送源程序
深入了解C#设计模式之订阅发布模式
08-19
首先，我们来看看如何使用委托来实现Pub-Sub发布订阅模式。下面是一个简单的示例代码： ```csharp namespace PubSubPattern { public class Pub { public Action OnChange { get; set; } public void Raise() ...
C# Redis发布订阅Demo
10-23
本教程将详细讲解如何在C#环境中利用Redis的发布订阅（Publish-Subscribe，简称Pub/Sub）机制实现跨进程通信，并且会涉及到Key过期通知的处理。 首先，我们需要了解Redis的发布订阅机制。在Redis中，发布订阅是一种...
C# Redis发布与订阅系统源码
11-13
首先，我们需要了解Redis的发布/订阅模式。在这个模式下，发送者（Publisher）将消息发布到一个频道（Channel），而订阅者（Subscriber）可以订阅这些频道并接收发布的消息。这种方式使得多个客户端可以实时共享信息...
C#.发布订阅模式
JaydenCheng的博客
05-10 2206
发布订阅模式 委托可以通过简单的加减实现封装多个方法，但容易出现封装了多个方法的委托被赋值号一下子都给替换掉的问题，即外部对象会影响其他对象对发布者的订阅。 委托类可以定义在发布者类之中吗? 可以的. 实现发布订阅模式的土方法：声明委托类，在发布者类中声明委托类成员，定义发布方法（事件触发），声明订阅类，在订阅类中声明订阅方法（绑定到订阅者的委托（事件）成员中）。 设计实验: 测试上述问题. 使用普通委托和匿名方法和 Lambda 表达式. 测试匿名函数情况下的变量作用域. // 发布者定义 publi
C#实现消息发布订阅即时通信Mqtt
08-14
一个简单的消息发布订阅的Demo,非常容易上手。分享出来，同时记录一下。下次再用到的时候可以找到。分享学习
消息订阅模式之拉模式的实现平台 C#语言
01-20
这是1.0版 ,2.0版已上传请关注我的其它资源 事件机制,可以极大化降低系统模块之间的耦合度! 做ERP,OA,CRM等应该说所有的系统都可以用这个平台, 实在是太好用了!逻辑比较复杂的地方用它简直就是救世主, 以前以为spring可以实现消息订阅模式,但是仔细研究后发现原来spring不是拉模式的,仍然是推模式的, 修改机制后必须得修改spring的配置文件,非常不爽! 于是这个简单小巧的拉模式平台出现了!用起来非常简单!只有两个方法! 而且与其他框架没有任何冲突!目前可以正常用在winform以及web项目下! 希望广大支持者踊跃发表支持,本人也好推出下一个更先进版本! 你的评论与支持是这个小平台继续走下去的支撑! EventPlatform是核心项目 Example 是 示例 TestProject1是单元测试 TestEventDriveWebApplication是web项目的测试 本平台永远开源!没有任何限制! 发现bug请email:273082449@qq.com 或QQ:273082449 欢迎各位网友反馈bug
opendds订阅发布c#封装1.0v
02-26
opendds是开源的发布订阅组件，c#封装第一版，用配置使用，资源中的配置文件全部是用的UDP协议。
C#中的事件（委托的发布和订阅、事件的发布和订阅、EventHandler类、Windows事件）
wenchm的博客
11-23 4415
C#中的事件是指某个类的对象在运行过程中遇到的一些特定事情，而这些特定的事情有必要通知给这个对象的使用者。当发生与某个对象相关的事件时，类会使用事件将这一对象通知给用户，这种通知即称为“引发事件”。引发事件的对象称为事件的源或发送者。
C#事件发布与订阅
qq_42265608的博客
05-08 1150
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace _1 { delegate void BookHand(string book);//引发事件 class BookStore { public event Book...
C# WPF MVVM模式Prism框架下事件发布与订阅
dotNET跨平台
11-20 930
01—前言 处理同模块不同窗体之间的通信和不同模块之间不同窗体的通信，Prism提供了一种事件机制，可以在应用程序中低耦合的模块之间进行通信，该机制基于事件聚合器服务，允许发布者和订...
C# 基于消息发布订阅模型的示例(下)
chinaherolts2008的博客
03-21 187
一 背景 　　在上面的一篇文章中我们介绍了一个完整地基于消息发布和订阅的模型，这篇文章我将介绍一种简单的基于消息的发布和订阅模型，在这个模型中我们将通过构建一个Publisher类来完成对特定的事件和事件订阅进行封装，这个是一个更加轻量级别的方式，使用这个的主要目的是降低类之间彼此的耦合程度，从而方便代码的扩展和访问，最终使代码结构更加合理。 我们首先来看看具体的Publisher类的构成，后面我们将会对这个类做一个详细的讲解和分析。 using System; using System.Collectio
c#事件的发布-订阅模型_.NET Core 事件总线,分布式事务解决方案：CAP
weixin_42144707的博客
12-18 1735
CAP 介绍CAP:GitHub​github.com开源协议：MITCAP 是一个在分布式系统中（SOA，MicroService）实现事件总线及最终一致性（分布式事务）的一个开源的 C# 库，她具有轻量级，高性能，易使用等特点。你可以轻松的在基于 .NET Core 技术的分布式系统中引入CAP，包括但限于 http://ASP.NET Core 和 http://ASP.NET Core o...
【C#与Redis】--高级主题--Redis 发布订阅
最新发布
喵叔
12-27 1682
发布订阅（Publish-Subscribe）是一种消息传递模式，用于在软件系统中实现解耦和灵活的组件通信。在发布订阅模式中，消息的发送者（发布者）并不直接将消息发送给特定的接收者（订阅者），而是将消息发送到一个中心化的调度机制，通常称为消息代理或主题（topic）。订阅者可以通过订阅特定的主题来接收感兴趣的消息，从而实现了解耦和松散耦合的通信方式。负责产生并发布消息的组件或模块。发布者将消息发送到消息代理而不关心谁订阅了这些消息。感兴趣并订阅特定主题的组件或模块。
C#实现RabbitMQ主题订阅模式解析MySQL数据教程
资源摘要信息:"C#开发的RabbitMQ主题订阅模式，读取mysql 数据发送和解析一体" 知识点： 1. C#编程语言：C#是一种由微软开发的面向对象的高级编程语言，广泛用于开发Windows桌面应用程序、服务器端应用程序以及Web...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值