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, "1");
            pbc.AddSubscribe("t1", Test5, "2");
            pbc.RemoveSubscribe("t1", "2");
            List<string> al = new List<string>();
            foreach (string item in pbc.Publish("t1"))
            {
                al.Add(item);
            }
            Assert.IsTrue(al.Count == 1);
            Assert.IsTrue(al[0] == "1");
            pbc.AddSubscribe("t1", Test5, "2");
            pbc.RemoveSubscribe("t1", "1");
            al.Clear();
            foreach (string item in pbc.Publish("t1"))
            {
                al.Add(item);
            }
            Assert.IsTrue(al.Count == 1);
            Assert.IsTrue(al[0] == "2");
        }

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

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

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

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

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

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

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