.net 多播委托的使用方法以及场景，更简单的观察者模式

首先来说一下什么是多播委托

多播委托就是在委托里定义一个或者多个方法的一个集合

使用方法：

public Action actList;
//添加方法
public void AddActionMethod()
{
   actList += //方法一
   actList += //方法二
   actList += //方法三
   actList += //方法四
}
//移除时从最后一个开始匹配，匹配到完全吻合的就会移除
//匿名方法，实例方法，内存路径不同匹配到的没有完全吻合，无法移除
public void RemoveActionMethod()
{
   actList -= //方法一
   actList -= //方法二
   actList -= //方法三
   actList -= //方法四
}
//执行方法，从第一个开始执行
public void ActInvoke()
{
   actList.Invoke();
}

以上就是多播委托的使用方法，不懂的可以参考一下更基础的：.NET 委托的使用方法以及使用委托的好处

下面做一个实际中的使用场景：如何使用委托来更好的实现《观察者模式》，不懂观察者模式的可以进去看看

观察者模式的代码我就不写了，直接上使用委托实现的观察者模式

//定义一个接口

　　public interface IObject
    {
        void DoAction();
    }
 　　/// <summary>
    /// 订阅者，继承接口
    /// 狗
    /// </summary>
   public class Dog:IObject
    {
        public void DoAction()
        {
            this.Wang();
        }
        /// <summary>
        /// 狗叫声
        /// </summary>
        public void Wang()
        {
            Console.WriteLine("狗叫了一声");
        }
    }
　　 /// <summary>
    /// 订阅者，继承接口
    /// 鸭子
    /// </summary>
    public class Duck : IObject
    {
        public void DoAction()
        {
            this.Ga();
        }
        /// <summary>
        /// 鸭子叫声
        /// </summary>
        public void Ga()
        {
            Console.WriteLine("鸭子嘎嘎嘎");
        }
    }
　　 /// <summary>
    /// 订阅者，继承接口
    /// 猪
    /// </summary>
   public class Pig:IObject
    {
        public void DoAction()
        {
            this.Heng();
        }
        /// <summary>
        /// 猪叫声
        /// </summary>
        public void Heng()
        {
            Console.WriteLine("猪哼哼哼");
        }
    }
　　 /// <summary>
    /// 订阅者，继承接口
    /// 老鼠
    /// </summary>
    public class Mouse : IObject
    {
        public void DoAction()
        {
            this.Zhi();
        }
        /// <summary>
        /// 老鼠叫声
        /// </summary>
        public void Zhi()
        {
            Console.WriteLine("老鼠吱吱叫");
        }
    }

以上是订阅者以及定义好的接口

    /// <summary>
    /// 发布者
    /// 一声喵叫引发一系列动作
    /// </summary>
    public class Cat
    {
        #region 观察者模式标准写法
        /// <summary>
        /// 观察者容器
        /// </summary>
        public List<IObject> _IObjectObserver = new List<IObject>();
        /// <summary>
        /// 添加动作
        /// 注册观察者
        /// </summary>
        /// <param name="iObject"></param>
        public void AddObject(IObject iObject)
        {
            this._IObjectObserver.Add(iObject);
        }
        /// <summary>
        /// 删除动作
        /// 注销观察者
        /// </summary>
        /// <param name="iObject"></param>
        public void RemoveObject(IObject iObject)
        {
            this._IObjectObserver.Remove(iObject);
        }
        /// <summary>
        /// 通知所有的观察者，执行动作
        /// </summary>
        public void MiaoObserver()
        {
            Console.WriteLine("--------观察者模式-------");
            foreach (var item in _IObjectObserver)
            {
                item.DoAction();
            }
        }
        #endregion

        #region 使用委托实现观察者模式
        /// <summary>
        /// 动作容器
        /// </summary>
        public Action MiaoAction;
        /// <summary>
        /// 执行委托中的动作
        /// </summary>
        public void MiaoActionMethod()
        {
            Console.WriteLine("--------委托执行动作-------");
            if (MiaoAction != null)
            {
                this.MiaoAction.Invoke();
            }
        }
        #endregion
    }

以上是发布者，一声猫的喵叫引发的一系列动作

 static void Main(string[] args)
        {
            //特殊类，无法被继承
            //System.MulticastDelegate

            //观察者模式的标准写法
            Cat cat = new Cat();
            cat.AddObject(new Dog());
            cat.AddObject(new Duck());
            cat.AddObject(new Pig());
            cat.AddObject(new Mouse());
            cat.MiaoObserver();

            //多播委托写法
            cat.MiaoAction += new Dog().Wang;
            cat.MiaoAction += new Duck().Ga;
            cat.MiaoAction += new Pig().Heng;
            cat.MiaoAction += new Mouse().Zhi;
            cat.MiaoActionMethod();

            Console.ReadLine();

        }

上面的例子是写了观察者模式跟委托放在一起，所以显得代码有点多

如果只使用多播委托来实现，去掉下面几个地方

/// <summary>
/// 使用委托就可以删除下面的接口
/// 以及所有实现该接口方法的类（只有子类的具体动作）
/// 使用委托可以完全丢弃这些
/// </summary>
public interface IObject
    {
        void DoAction();
    }

使用多播委托来实现观察者模式，不需要该接口以及接口的实现

如果对观察者模式有一定了解的应该就可以清楚，使用多播委托来实现观察者模式，可以省事很多，减少大量代码

代码有点多，仔细琢磨一下，或者自己写一遍来体会一些这个场景下多播委托的神奇