C#实现发布订阅模式

首先给出项目的结构

IPublish.cs的源码：

 namespace NsWebChat.PublishSubscribe
 {
     /// <summary>
     /// 发布事件基础接口
     /// </summary>
     public interface IPublish
     {
         string PublishTag { get; set; }
         object PublishData { get; set; }
     }
 }

IPubSubCenter.cs的源码：

 namespace NsWebChat.PublishSubscribe
 {
     /// <summary>
     /// 订阅发布中心基础接口
     /// </summary>
     public interface IPubSubCenter
     {
         /// <summary>
         /// 订阅事件
         /// </summary>
         bool AddSubscribe(string tag, Func<ISubscribe, object, object> method, object data, string name);
         bool AddSubscribe(string tag, Func<ISubscribe, object, object> method, string name);
         bool AddSubscribe(Subscribe subscribe);
         /// <summary>
         /// 获得指定事件的订阅列表
         /// </summary>
         SubscribeList GetSubscribeList(string tag);
         /// <summary>
         /// 获得订阅
         /// </summary>
         Subscribe GetSubscribe(string tag, string name);
         /// <summary>
         /// 删除订阅
         /// </summary>
         void RemoveSubscribe(string tag, string name);

         /// <summary>
         /// 发布事件
         /// </summary>
         IEnumerable<Object> Publish(string tag, object data);
         IEnumerable<Object> Publish(string tag);
         IEnumerable<Object> Publish(Publish publish);
     }
 }

ISubscribe.cs的源码：

 namespace NsWebChat.PublishSubscribe
 {
     /// <summary>
     /// 订阅事件基础接口
     /// </summary>
     public interface ISubscribe
     {
         /// <summary>
         /// 订阅的事件
         /// </summary>
         string SubscribeTag { get; set; }
         /// <summary>
         /// 订阅的名称
         /// </summary>
         string SubscribeName { get; set; }
         /// <summary>
         /// 响应发布时传递的参数
         /// </summary>
         object Data { get; set; }
         /// <summary>
         /// 响应发布的方法
         /// </summary>
         Func<ISubscribe, object, object> SubscribeMethod { get; set; }
         /// <summary>
         /// 调用订阅方法
         /// </summary>
         object Invoke(object val);
     }
 }

Publish.cs的源码：

 namespace NsWebChat.PublishSubscribe
 {
     /// <summary>
     /// 发布事件基类
     /// </summary>
     public class Publish : IPublish
     {
         private string _publishTag;
         private object _publishData;

         public Publish()
         {
         }

         public Publish(string tag)
             : this(tag, new object())
         {

         }

         public Publish(string tag, object val)
         {
             _publishTag = tag;
             _publishData = val;
         }

         public string PublishTag
         {
             get
             {
                 return _publishTag;
             }
             set
             {
                 _publishTag = value;
             }
         }

         public object PublishData
         {
             get
             {
                 return _publishData;
             }
             set
             {
                 _publishData = value;
             }
         }
     }
 }

PubSubCenter.cs的源码：

 namespace NsWebChat.PublishSubscribe
 {
     /// <summary>
     /// 订阅发布中心基类
     /// </summary>
     public class PubSubCenter : IPubSubCenter

     {
         private Dictionary<string, SubscribeList> _pubsubList = new Dictionary<string, SubscribeList>();

         public bool AddSubscribe(string tag, Func<ISubscribe, object, object> method, object data ,string name)
         {
             Subscribe subscribe = new Subscribe();
             subscribe.Data = data;
             subscribe.SubscribeMethod = method;
             subscribe.SubscribeTag = tag;
             subscribe.SubscribeName = name;
             return AddSubscribe(subscribe);
         }

         public bool AddSubscribe(string tag, Func<ISubscribe, object, object> method, string name)
         {
             return AddSubscribe(tag, method, new object(),name);
         }

         public bool AddSubscribe(Subscribe subscribe)
         {
             if (subscribe == null)
             {
                 return false;
             }
             else
             {
                 if (String.IsNullOrEmpty(subscribe.SubscribeName))
                 {
                     return false;
                 }
                 Subscribe subscribet = GetSubscribe(subscribe.SubscribeTag, subscribe.SubscribeName);
                 if (subscribet != null)
                 {
                     return false;
                 }
                 else
                 {
                     if (_pubsubList.ContainsKey(subscribe.SubscribeTag))
                     {
                         _pubsubList[subscribe.SubscribeTag].Add(subscribe);
                     }
                     else
                     {
                         SubscribeList list = new SubscribeList();
                         list.Add(subscribe);
                         _pubsubList.Add(subscribe.SubscribeTag, list);
                     }
                     return true;
                 }
             }
         }

         public SubscribeList GetSubscribeList(string tag)
         {
             if (_pubsubList.ContainsKey(tag))
             {
                 return _pubsubList[tag];
             }
             else
             {
                 return new SubscribeList();
             }
         }

         public Subscribe GetSubscribe(string tag, string name)
         {
             if (_pubsubList.ContainsKey(tag))
             {
                 foreach (Subscribe item in _pubsubList[tag])
                 {
                     if (item.SubscribeName == name)
                     {
                         return item;
                     }
                 }
                 return null;
             }
             else
             {
                 return null;
             }
         }

         public void RemoveSubscribe(string tag, string name)
         {
             Subscribe subscribe = GetSubscribe(tag, name);
             _pubsubList[tag].Remove(subscribe);
         }

         public IEnumerable<object> Publish(string tag, object data)
         {
             if (_pubsubList.ContainsKey(tag))
             {
                 foreach (Subscribe item in _pubsubList[tag])
                 {
                     yield return item.Invoke(data);
                 }
             }
             else
             {
                 yield break;
             }
         }

         public IEnumerable<object> Publish(string tag)
         {
             return Publish(tag, new object());
         }

         public IEnumerable<object> Publish(Publish publish)
         {
             return Publish(publish.PublishTag, publish.PublishData);
         }
     }
 }

Subscribe.cs源码：

 namespace NsWebChat.PublishSubscribe
 {
     /// <summary>
     /// 订阅事件基类
     /// </summary>
     public class Subscribe : ISubscribe
     {
         private object _data;
         private Func<ISubscribe, object, object> _subscribeMethod;
         private string _subscribeTag;
         private string _subscribeName;

         public Subscribe()
         {
         }

         public Subscribe(string tag, Func<ISubscribe, object, object> method)
             : this(tag, method, "")
         {

         }

         public Subscribe(string tag, Func<ISubscribe, object, object> method, object data)
             : this(tag, method, data, "")
         {

         }

         public Subscribe(string tag, Func<ISubscribe, object, object> method,string name)
             : this(tag, method, new object(), name)
         {

         }

         public Subscribe(string tag, Func<ISubscribe, object, object> method, object data,string name)
         {
             _data = data;
             _subscribeTag = tag;
             _subscribeMethod = method;
             _subscribeName = name;
         }

         public object Data
         {
             get
             {
                 return _data;
             }
             set
             {
                 _data = value;
             }
         }

         public Func<ISubscribe, object, object> SubscribeMethod
         {
             get
             {
                 return _subscribeMethod;
             }
             set
             {
                 _subscribeMethod = value;
             }
         }

         public object Invoke(object val)
         {
             return SubscribeMethod(this, val);
         }

         public string SubscribeTag
         {
             get
             {
                 return _subscribeTag;
             }
             set
             {
                 _subscribeTag = value;
             }
         }

         public string SubscribeName
         {
             get
             {
                 return _subscribeName;
             }
             set
             {
                 _subscribeName = value;
             }
         }
     }
 }

SubscribeList.cs的源码：

 namespace NsWebChat.PublishSubscribe
 {
     /// <summary>
     /// 订阅列表
     /// </summary>
     public class SubscribeList : IList<Subscribe>
     {
         private List<Subscribe> subscribes = new List<Subscribe>();

         public int IndexOf(Subscribe item)
         {
             return subscribes.IndexOf(item);
         }

         public void Insert(int index, Subscribe item)
         {
             subscribes.Insert(index, item);
         }

         public void RemoveAt(int index)
         {
             subscribes.RemoveAt(index);
         }

         public Subscribe this[int index]
         {
             get
             {
                 return subscribes[index];
             }
             set
             {
                 subscribes[index] = value;
             }
         }

         public void Add(Subscribe item)
         {
             subscribes.Add(item);
         }

         public void Clear()
         {
             subscribes.Clear();
         }

         public bool Contains(Subscribe item)
         {
             return subscribes.Contains(item);
         }

         public void CopyTo(Subscribe[] array, int arrayIndex)
         {
             subscribes.CopyTo(array, arrayIndex);
         }

         public int Count
         {
             get
             {
                 return subscribes.Count;
             }
         }

         public bool IsReadOnly
         {
             get { return false; }
         }

         public bool Remove(Subscribe item)
         {
             return subscribes.Remove(item);
         }

         public IEnumerator<Subscribe> GetEnumerator()
         {
             return subscribes.GetEnumerator();
         }

         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
         {
             return subscribes.GetEnumerator();
         }
     }
 }

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

 namespace WebChatUnitTest
 {
     [TestClass]
     public class PubSubCenterTest
     {
         public object Test1(ISubscribe subscribe, object data)
         {
             Assert.IsTrue(subscribe.Data == data);
             return data;
         }

         public object Test2(ISubscribe s, object d)
         {
             return d;
         }

         public object Test3(ISubscribe s, object d)
         {
             return d;
         }

         public object Test4(ISubscribe s, object d)
         {
             return d;
         }

         public object Test5(ISubscribe s, object d)
         {
             return s.SubscribeName;
         }

         //测试删除订阅
         [TestMethod]
         public void TestRemoveSubscribe()
         {
             PubSubCenter pbc = new PubSubCenter();
             pbc.AddSubscribe("t1", Test5, "");
             pbc.AddSubscribe("t1", Test5, "");
             pbc.RemoveSubscribe("t1", "");
             List<string> al = new List<string>();
             foreach (string item in pbc.Publish("t1"))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsTrue(al[] == "");
             pbc.AddSubscribe("t1", Test5, "");
             pbc.RemoveSubscribe("t1", "");
             al.Clear();
             foreach (string item in pbc.Publish("t1"))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsTrue(al[] == "");
         }

         //测试重载版本的订阅发布
         [TestMethod]
         public void TestMoreSubscribeAndPublish()
         {
             PubSubCenter pbc = new PubSubCenter();
             Subscribe subscribe = new Subscribe("t1", Test2, "", "");
             Subscribe subscribe2 = new Subscribe("t1", Test2, "");
             Subscribe subscribe3 = new Subscribe();
             subscribe3.SubscribeMethod = Test2;
             subscribe3.SubscribeName = "";
             subscribe3.SubscribeTag = "t1";
             pbc.AddSubscribe(subscribe);
             pbc.AddSubscribe(subscribe2);
             pbc.AddSubscribe(subscribe3);
             pbc.AddSubscribe("t1", Test2, "");
             pbc.AddSubscribe("t1", Test2, "", "");
             List<object> al = new List<object>();
             foreach (object item in pbc.Publish("t1"))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             al.Clear();
             foreach (object item in pbc.Publish("t1",""))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);

             Publish pub = new Publish("t1");
             al.Clear();
             foreach (object item in pbc.Publish(pub))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);

             pub = new Publish("t1", "");
             al.Clear();
             foreach (object item in pbc.Publish(pub))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);

             pub = new Publish();
             pub.PublishData = "";
             pub.PublishTag = "t1";
             al.Clear();
             foreach (object item in pbc.Publish(pub))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
             Assert.IsNotNull(al[]);
         }

         //测试重名订阅事件
         [TestMethod]
         public void TestSameNameSubscribe()
         {
             PubSubCenter pbc = new PubSubCenter();
             pbc.AddSubscribe("t1", Test2, "");
             pbc.AddSubscribe("t1", Test2, "");
             pbc.AddSubscribe("t1", Test2, "");
             List<string> al = new List<string>();
             foreach (string item in pbc.Publish("t1", ""))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsTrue(al[] == "");
             Assert.IsTrue(al[] == "");
         }

         //测试多方法订阅单事件
         [TestMethod]
         public void TestMoreSubscribeToOnePublish()
         {
             PubSubCenter pbc = new PubSubCenter();
             pbc.AddSubscribe("t1", Test2, "");
             pbc.AddSubscribe("t1", Test3, "");
             pbc.AddSubscribe("t1", Test4, "");
             List<string> al = new List<string>();
             foreach (string item in pbc.Publish("t1", ""))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsTrue(al[] == "");
             Assert.IsTrue(al[] == "");
             Assert.IsTrue(al[] == "");
         }

         //测试单方法订阅多事件
         [TestMethod]
         public void TestOneSubscribeToMorePublish()
         {
             PubSubCenter pbc = new PubSubCenter();
             pbc.AddSubscribe("t1", Test1, "", "t1");
             pbc.AddSubscribe("t2", Test1, "", "t2");
             pbc.AddSubscribe("t3", Test1, "", "t3");
             pbc.AddSubscribe("t4", Test1, "", "t4");
             IList<String> al = new List<String>();
             foreach(String item in pbc.Publish("t1",""))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsTrue(al[] == "");
             al.Clear();
             foreach (String item in pbc.Publish("t2", ""))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsTrue(al[] == "");
             al.Clear();
             foreach (String item in pbc.Publish("t3", ""))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsTrue(al[] == "");
             al.Clear();
             foreach (String item in pbc.Publish("t4", ""))
             {
                 al.Add(item);
             }
             Assert.IsTrue(al.Count == );
             Assert.IsTrue(al[] == "");
         }
     }
 }