C# 委托 事件

一：什么叫委托

通过反射发现，委托其实是一个类，继承自System.MulticastDelegate，但是System.MulticastDelegate这个类是特殊类，不能被继承

二：委托的声明 

public delegate void NoReturnNoParaOutClass();
 public class MyDelete
 {
      public delegate void NoReturnNoPara<T>(T t);
      public delegate void NoReturnNoPara();
      public delegate void NoReturnWithPara(int x, int y);
      public delegate int WithReturnNoPara();
      public delegate string WithReturnWithPara(out int x, ref int y);
    }

委托可以声明在类外面，可以声明再类里面

三：委托的实例和调用 

private int GetSomething()
        {
            return 1;
        }
        private int GetSomething2()
        {
            return 2;
        }

        private int GetSomething3()
        {
            return 3;
        }
        private void DoNothing()
        {
            Console.WriteLine("This is DoNothing");
        }
        private static void DoNothingStatic()
        {
            Console.WriteLine("This is DoNothingStatic");
        }
        public string ParaReturn(out int x, ref int y)
        {
            throw new Exception();
        }

//多种途径实例化，要求传递一个参数类型，返回值都跟委托一致的方法
{
   WithReturnWithPara method = new WithReturnWithPara(ParaReturn);
   int x = 0;
   int y = 0;
   var dd = method.Invoke(out x, ref y);
 }
//begininvoke
{
   WithReturnNoPara method = new WithReturnNoPara(this.GetSomething);
   int iResult = method.Invoke();
   iResult = method();
   var result = method.BeginInvoke(null, null);//异步调用
   method.EndInvoke(result);
}
{
   NoReturnNoPara method = new NoReturnNoPara(this.DoNothing);
   //委托实力的调用，参数和委托约束的一致
    method.Invoke(); //1
    //method(); //2
    //method.BeginInvoke(null, null); //3
    //this.DoNothing(); //1,2,3都等同于this.DoNothing

}
{
     NoReturnNoPara method = new NoReturnNoPara(DoNothingStatic);
}
{
    NoReturnNoPara method = new NoReturnNoPara(Student.StudyAdvanced);
}
{
    NoReturnNoPara method = new NoReturnNoPara(new Student().Study);
}

四：为什么要使用委托

有时候我们声明一个方法，直接调用蛮好的，为啥还要使用委托，然后还要先声明，再实例化，再inovke调用呢？

下面我们举个例子，比如一个人问好这件事情，不同人问候方式不一样，我们会先定义一个类型，如枚举

public enum PeopleType
 {
        Chinese,
        America,
        Japanese
 }

然后通过不同的类型来判断问候方式不同，如下

/// 为不同的人，进行不同的问候
        /// 传递变量--判断一下----执行对应的逻辑
        /// </summary>
        /// <param name="name"></param>
        /// <param name="peopleType"></param>
        public void SayHi(string name, PeopleType peopleType)
        {
            switch (peopleType)
            {
                case PeopleType.Chinese:
                    Console.WriteLine($"{name}晚上好");
                    break;
                case PeopleType.America:
                    Console.WriteLine($"{name},good evening");
                    break;
                case PeopleType.Japanese:
                    Console.WriteLine($"{name},&&%*^^***@@@&&&&");
                    break;
                default:
                    throw new Exception("wrong peopleType"); //遇到异常报错
            }
        }

这样做的好处是：以后如果增加公共逻辑等比较容易，但是如果类型比较多，这个方法会变成无限制改动，导致方法难以维护，于是很多人想着增加分支，就增加方法--不影响别的方法的思路来改善

public void SayHiChinese(string name)
  {
         Console.WriteLine($"{name}晚上好");
  }
  public void SayHiJapanese(string name)
  {
         Console.WriteLine($"{name},&&%*^^***@@@&&&&");
  }
  public void SayHiAmerican(string name)
  {
          Console.WriteLine($"{name},good evening");
  }

然后上层判断调用

这样做的好处是：修改某个方法--不影响别的方法 ，但是缺点却是：增加公共逻辑---多个方法就有很多重复代码

那么我们想：既增加逻辑方便，又维护简单，鱼肉熊掌，如何兼得呢？

我们可以把相应的逻辑做为参数传进来，这样就解决了我们的问题

具体我们可以按照以下来做：

public void SayHiPerfact(string name, SayHiDeletegate method)
  {
      Console.WriteLine("增加开始日志");
      method.Invoke(name);
      Console.WriteLine("增加结束日志");          
  }
  public delegate void SayHiDeletegate(string name);

然后调用的时候如下：

  SayHiDeletegate method = new SayHiDeletegate(SayHiChinese);

这样就做到了

1：逻辑解耦，方便维护 

2：代码重构，去掉重复

其实这也是我们选择使用委托的两大优点

注意：以上我们纯粹为了定义委托而定义委托，其实框架已经我们帮我们定义了Action 和Func这两个委托，Action是没有返回值，Func是有返回值的，这两个委托类已经足够我们使用了，所以有时候我们使用的时候，没有必要自己再去定义，而直接使用即可