C#委托、事件、工厂模式个人见解

有一点混淆了三者的用法，索性拆分开来，同一个函数，看他们是怎样实现的，再来看区别。

1.委托：方法的参数也是方法

 public class MyDelegate
    {
        //定义委托
        public delegate double DelegateCaculate(double a, double b);

        //加
        public double Add(double a, double b)
        {
            Console.Write("加法 ");
            return a + b;
        }
        //减
        public double Subtract(double a, double b)
        {
            Console.Write("减法 ");
            return a - b;
        }

        //乘
        public double Multiply(double a, double b)
        {
            Console.Write("乘法 ");
            return a * b;
        }

        public double Caculate(double a, double b, DelegateCaculate myDelegate) => myDelegate(a, b);

    }

调用方式一：

class Program
    {
        static void Main(string[] args)
        {
            MyDelegate dele = new MyDelegate();
            var res = dele.Caculate(1, 2, dele.Add);
            Console.Write(res);
            Console.ReadKey();
        }
    }

输出：加法 3

调用方式二：

 DelegateCaculate del = new DelegateCaculate(myDele.Add);
            var res1=del(1, 2);

            Console.Write(res1);
            Console.ReadKey();

输出：加法  3

总之，委托将方法作为另一个方法的参数来传递，避免了大量的条件匹配，扩展性也更好。

可以为同一个委托变量制定多个方法：

 static void Main(string[] args)
        {
            MyDelegate myDele = new MyDelegate();

            MyDelegate.DelegateCaculate dele1;
            dele1 = myDele.Add;
            dele1 += myDele.Subtract;
            dele1 -= myDele.Multiply;
            var res = dele1(1, 2);

            Console.Write(res);
            Console.ReadKey();
        }

2.事件

基本步骤：

• 申明事件委托对象
• 定义事件对象，event关键字
• 添加事件到事件队列(+=，删除用-=)
• 定义事件促发
  

 class MyEvent
    {
        //定义事件委托
        public delegate void EventTestHandler(object sender, EventArgs e);

        //事件对象
        public event EventTestHandler eventTestHandler;

        //构造方法
        public MyEvent()
        {
            //将事件添加到队列中
            eventTestHandler += new EventTestHandler(OnInputChange);
        }

        //声明一个事件
        protected virtual void OnInputChange(object sender, EventArgs e)
        {
            if (eventTestHandler != null)
            {
                eventTestHandler(sender, e);
            }
            Console.WriteLine("{0}，事件调用。", e.ToString());
        }

        //调用事件对象，促发函数
        public void OneventTestHandler(EventArgs e)
        {
            eventTestHandler(this, e);
        }

        //促发事件
        public void TriggerEvent()
        {
            EventArgs e = new EventArgs();
            OneventTestHandler(e);
        }

    }

调用：

static void Main(string[] args)
        {
            MyEvent myEvent = new MyEvent();
            myEvent.TriggerEvent();
            Console.ReadKey();
        }

3.简单工厂

一种设计模式，类似工厂，根据不同参数，生产不同产品。

 /// <summary>
    /// 抽象父类
    /// </summary>
    public abstract class Language
    {
        //抽象方法，用于子类重写
        public abstract void Say();
    }

    //英语继承语言类
    public class English : Language
    {
        public override void Say()
        {
            Console.Write("hello");
        }
    }

    public class Chinese : Language
    {
        public override void Say()
        {
            Console.Write("你好");
        }
    }

 /// <summary>
    /// 工厂类，
    /// </summary>
    public static class LanguageFactory
    {
        public static Language SayWords(string county)
        {
            Language language = null;
            if (county == "England")
            {
                language = new English();
            }
            return language;
        }
    }

调用：

 static void FactoryFunc()
        {
            Language language= LanguageFactory.SayWords("England");
            language.Say();
        }

输出：hello

4.总结

• 委托是事件。
• 委托和工厂模式一样，避免了大量if 判断，达到了解耦。
  

             不过，工厂模式是前人总结的编程经验和思路，是在解决多条件分支情况下，用类继承实现解耦目的。

不知道我这样想有没有错：委托是一种特殊的工厂模式，是利用工厂模式的思路，把多个实现方法封装在一个(工厂)类里。只是调用的时候，前者传的参数就是方法，而后者按需实例化子类对象。一个更直接，一个依赖类之间的关系。