C#中的委托和事件-C#/.NET开发

这篇文章介绍了C#中的委托和事件，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

一、委托

1、什么是委托

委托是面向对象的、类型安全的，是引用类型。使用delegate关键字进行定义。委托的本质就是一个类，继承自System.MulticastDelegate，而它又派生自System.Delegate。里面内置了几个方法，可以在类的外面声明委托，也可以在类的内部声明委托。

对委托的使用：先定义，后声明和实例化委托，然后作为参数传递给方法。

1.1 定义委托

下面是几种委托定义的例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyDelegateDemo
{
    // 也可以在类的外面定义委托
    public delegate void NoReturnNoParaOutClass();

    public class MyDelegate
    {
        // 声明无参数无返回值的泛型委托
        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);
    }
}

1.2 声明并实例化委托

实例化委托时参数传递的是一个方法，方法的签名必须和委托的签名一样（即方法的返回值类型、参数列表的参数类型都必须和定义的委托一致）。

// 委托的实例化，DoNothing是一个方法
// NoReturnNoPara是定义的无参无返回值的委托，所以DoNothing方法也必须是无参无返回值的
NoReturnNoPara method = new NoReturnNoPara(DoNothing);

DoNothing()方法定义如下：

private void DoNothing()
{
    Console.WriteLine("This is DoNothing");
}

1.3 委托实例的调用

// 调用委托
method.Invoke();
// Invoke也可以去掉
method();

注意：委托的调用和直接执行方法的效果是一样的，例如：

// 调用委托
method.Invoke();
// Invoke也可以去掉
method();
// 直接执行方法
this.DoNothing();

在控制台的Main()方法里面，结果如下：

从截图中能够看出：三种方式的输出结果都是一样的。

2、委托类型和委托实例

委托类型：定义了委托实例可以调用的那类方法，具体来说，委托类型定义了方法的返回类型和参数类型，下面的代码定义了一个委托类型：

// 规定了可以调用的方法的返回值类型是int，有一个类型为int的参数
delegate  int Transformer(int x);

委托实例：把方法赋值给委托变量的时候就创建了委托实例，例如下面的代码：

Transformer t =new Transformer(Square);

也可以简写为下面的形式：

Transformer t = Square;

Square是定义的一个方法，其方法定义如下：

int Square(int x)
{
    return  x*x;
}

委托的实例其实就是调用者的委托：调用者调用委托，然后委托调用目标方法，间接的把调用者和目标方法解耦合。

讲到这里可能有人会问：既然使用委托和直接调用方法的效果是一样的，那为什么还要使用委托呢，直接调用方法多么简单？下面先来看一个实际的例子。

先定义一个Student类，里面有一些属性和方法，Student类定义如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyDelegateDemo
{
    public class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int ClassId { get; set; }
        public int Age { get; set; }

        public static void Show()
        {
            Console.WriteLine("123");
        }
    }
}

然后使用集合初始化器的方式初始化一个List<Student>集合，填充一些测试数据：

private List<Student> GetStudentList()
{
            #region 初始化数据
            List<Student> studentList = new List<Student>()
            {
                new Student()
                {
                    Id=1,
                    Name="老K",
                    ClassId=2,
                    Age=35
                },
                new Student()
                {
                    Id=1,
                    Name="hao",
                    ClassId=2,
                    Age=23
                },
                 new Student()
                {
                    Id=1,
                    Name="大水",
                    ClassId=2,
                    Age=27
                },
                 new Student()
                {
                    Id=1,
                    Name="半醉人间",
                    ClassId=2,
                    Age=26
                },
                new Student()
                {
                    Id=1,
                    Name="风尘浪子",
                    ClassId=2,
                    Age=25
                },
                new Student()
                {
                    Id=1,
                    Name="一大锅鱼",
                    ClassId=2,
                    Age=24
                },
                new Student()
                {
                    Id=1,
                    Name="小白",
                    ClassId=2,
                    Age=21
                },
                 new Student()
                {
                    Id=1,
                    Name="yoyo",
                    ClassId=2,
                    Age=22
                },
                 new Student()
                {
                    Id=1,
                    Name="冰亮",
                    ClassId=2,
                    Age=34
                },
                 new Student()
                {
                    Id=1,
                    Name="瀚",
                    ClassId=2,
                    Age=30
                },
                new Student()
                {
                    Id=1,
                    Name="毕帆",
                    ClassId=2,
                    Age=30
                },
                new Student()
                {
                    Id=1,
                    Name="一点半",
                    ClassId=2,
                    Age=30
                },
                new Student()
                {
                    Id=1,
                    Name="小石头",
                    ClassId=2,
                    Age=28
                },
                new Student()
                {
                    Id=1,
                    Name="大海",
                    ClassId=2,
                    Age=30
                },
                 new Student()
                {
                    Id=3,
                    Name="yoyo",
                    ClassId=3,
                    Age=30
                },
                  new Student()
                {
                    Id=4,
                    Name="unknown",
                    ClassId=4,
                    Age=30
                }
            };
            #endregion
            return studentList;
}

现在有一个需求，找出List<Student>集合里面年龄大于25的学生信息，代码如下：

List<Student> studentList = this.GetStudentList();
//找出年龄大于25
List<Student> resultAge = new List<Student>();//准备容器
foreach (Student student in studentList)//遍历数据源
{
      if (student.Age > 25)//判断条件
      {
           resultAge.Add(student);//满足条件的放入容器
      }
}
Console.WriteLine($"结果一共有{resultAge.Count()}个");

使用一个foreach循环很容易得到全部年纪大于25的学生，这时又提出了需求：找出name长度大于2的学生、找出Name长度大于2 而且年龄大于25 而且班级id是2的学生，代码如下：

//找出Name长度大于2
List<Student> resultName = new List<Student>();
foreach (Student student in studentList)
{
       if (student.Name.Length > 2)
       {
              resultName.Add(student);
       }
}
Console.WriteLine($"结果一共有{resultName.Count()}个");

//找出Name长度大于2 而且年龄大于25 而且班级id是2
List<Student> result = new List<Student>();
foreach (Student student in studentList)
{
        if (student.Name.Length > 2 && student.Age > 25 && student.ClassId == 2)
        {
            result.Add(student);
        }
}
Console.WriteLine($"结果一共有{result.Count()}个");

观察上面的代码，你会发现里面有很多重复的代码：每次都要先准备一个查询结果集的集合，然后遍历数据源，判断条件，把满足条件的放入到集合中。可不可以把上面的代码进行优化呢？请看下面的代码：

private List<Student> GetList(List<Student> source, int type)
{
            List<Student> result = new List<Student>();
            foreach (Student student in source)
            {
                switch(type)
                {
                    case 1:
                        if (student.Age > 25)
                        {
                            result.Add(student);
                        }
                        break;
                    case 2:
                        if (student.Name.Length > 2)
                        {
                            result.Add(student);
                        }
                        break;
                    case 3:
                        if (student.Name.Length > 2 && student.Age > 25 && student.ClassId == 2)
                        {
                            result.Add(student);
                        }
                        break;
                }
            }
            return result;
}

在上面这段代码中，每次根据不同的type类型执行不同的判断条件，这样看起来可以把一些重复的代码进行了重用，但是这样又会有其他的问题：所有的判断逻辑都写在了一起，如果又增加了一种type类型或者判断逻辑改变了，就要修改整个代码，违反了开闭原则。

仔细观察上面的这段代码：GetList()方法需要传入一个int类型的参数，根据不同的参数，执行对应的逻辑。那么可不可以直接传递逻辑进来呢？逻辑就是方法，也就是说能不能传递一个方法进来。可能有人会问题，方法都是进行调用啊，怎么能进行传递呢？答案是肯定的：那就是使用上面讲到的委托。

以查询年龄大于25的学生为例：逻辑就是判断学生的年龄是否大于25，返回一个bool值，如果大于25就添加到集合中，根据逻辑，可以得到下面的方法：

private bool Than(Student student)
{
      return student.Age > 25;
}

根据这个方法的签名可以定义如下的委托：

// 定义委托
public delegate bool ThanDelegate(Student student);

修改上面GetList的方法，把委托作为参数传递进来：

private List<Student> GetListDelegate(List<Student> source, ThanDelegate method)
{
       List<Student> result = new List<Student>();
       foreach (Student student in source)
       {
             // 调用委托
             if (method.Invoke(student))
             {
                 result.Add(student);
              }
        }
        return result;
}

实例化委托：

// 实例化委托
ThanDelegate method = new ThanDelegate(this.Than);
List<Student> resultDele = this.GetListDelegate(studentList, method);
Console.WriteLine($"结果一共有{resultDele.Count()}个");

另外两个可以定义如下的方法：

/// <summary>
/// 查询Name长度大于2
/// </summary>
/// <param name="student"></param>
/// <returns></returns>
private bool LengthThan(Student student)
{
      return student.Name.Length > 2;
}

/// <summary>
/// 查询Name长度大于2 而且年龄大于25 而且班级id是2
/// </summary>
/// <param name="student"></param>
/// <returns></returns>
private bool AllThan(Student student)
{
      return student.Name.Length > 2 && student.Age > 25 && student.ClassId == 2;
}

实例化委托如下：

//Name长度大于2
ThanDelegate nameMethod = new ThanDelegate(LengthThan);
List<Student> nameList= this.GetListDelegate(studentList, nameMethod);
Console.WriteLine($"Name长达大于2的结果一共有{nameList.Count()}个");

//Name长度大于2 而且年龄大于25 而且班级id是2
ThanDelegate allMethod = new ThanDelegate(AllThan);
List<Student> allList = this.GetListDelegate(studentList, allMethod);
Console.WriteLine($"Name长度大于2 而且年龄大于25 而且班级id是2的结果一共有{nameList.Count()}个");

观察GetListDelegate这个方法：保留了以前公用的代码：准备一个结果集的集合、循环遍历数据源，把符合条件的学生添加到结果集中，而判断逻辑放到了单独的一个方法中，如果判断逻辑改变了或者需要增加新的判断逻辑，只需要修改原有的判断逻辑或者新增判断逻辑即可，这样可以做到不需要修改GetListDelegate()这个方法，很好的符合开不原则。

可以总结出委托的一个应用：委托可以解除公用逻辑(准备结果集的集合、循环遍历数据源，添加到结果集中)和具体的业务逻辑(例如判断年龄大于25)的耦合，可以减少重复的代码。

2、多种途径实例化委托

委托实例化的时候不仅可以传入当前类型的普通方法，还可以传入静态、实例方法等，例如：

// 传入当前类型的普通方法
NoReturnNoPara method = new NoReturnNoPara(DoNothing);
// 传入当前类型的静态方法
NoReturnNoPara methodStatic = new NoReturnNoPara(DoNothingStatic);
// 传入其他类型的静态方法
NoReturnNoPara methodOtherStaitc = new NoReturnNoPara(Student.StudyAdvanced);
// 传入其他类型的普通方法
NoReturnNoPara methodOther = new NoReturnNoPara(new Student().Study);

其中DoNothingStatic()方法定义如下：

private void DoNothingStatic()
{
     Console.WriteLine("This is DoNothingStatic");
}

Student类的静态方法和实例方法定义如下：

public static void StudyAdvanced()
{
      Console.WriteLine("欢迎学习高级班课程");
}

public void Study()
{
      Console.WriteLine("学习");
}

总结：实例化委托时传入的方法只有一个要求：方法的签名和委托的签名一样，即返回值类型和参数列表一致，无论该方法来自于当前类型的普通方法、静态方法或者其他类型的实例方法和静态方法。

3、链式委托

链式委托也被称为“多播委托”，其本质是一个由多个委托组成的链表。我们知道，所有的自定义委托都继承自System.MulticastDelegate类，这个类就是为链式委托而设计的。当两个及以上的委托被链接到一个委托链时，调用头部的委托将导致该链上的所有委托方法都被执行。

像上面实例化委托的时候，一个委托类型的变量只能保存一个方法，使用多播委托，一个委托类型的变量可以保存多个方法，多播委托可以增加、减少委托，Invoke的时候可以按顺序执行。

+= 为委托实例按顺序增加方法，形成方法链，Invoke时，按顺序依次执行，例如下面的代码：

// 实例化委托
NoReturnNoPara method = new NoReturnNoPara(DoNothing);
method += new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(DoNothingStatic);
method += new NoReturnNoPara(Student.StudyAdvanced);
method += new NoReturnNoPara(new Student().Study);
method.Invoke();

+=委托的最后输出结果是什么是？请看下面的截图：

可以看到，调用头部的委托导致了所有委托方法的执行。为委托+=增加方法让我们看起来像是委托被修改了，其实它们并没有被修改。事实上，委托是不变的。在给委托增加或移除方法时，实际发生的是创建了一个新的委托。

从上面的截图中可以看出：多播委托的执行结果是把所有传入的方法都执行一遍，而且是按照实例化时传入方法的顺序依次执行的。(上面传入了两次当前类型的DoNoThing方法，所以会执行两边。)

-= 为委托实例移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的，移除且只移除一个，没有也不异常。

method -= new NoReturnNoPara(this.DoNothing);
method -= new NoReturnNoPara(DoNothingStatic);
method -= new NoReturnNoPara(Student.StudyAdvanced);
method -= new NoReturnNoPara(new Student().Study);
method.Invoke();

移除委托的执行结果是什么呢？在上面添加委托的时候传入了5个方法，移除委托的时候移除了4个方法，应该只会执行DoNothing()这一个方法，是这样的吗？看看下面的运行结果：

从截图中可以看出，最后的结果和我们猜测的结果不同，除了执行DoNothing()方法以外，还执行了Study()方法，但是添加的时候我们只添加了一个Study()方法，而且后面又移除掉了，那为什么还会执行这个方法呢？原因是因为添加和移除时候不是同一个实例的Study()方法(添加和移除的时候都是new了一个新实例)，所以移除的时候不会被移除掉。怎么证明上面的原因是否正确呢？请看下面的代码：

Console.WriteLine("***多播委托添加方法***");
// 实例化一个Student对象
Student student = new Student();
// 实例化委托
NoReturnNoPara method = new NoReturnNoPara(DoNothing);
method += new NoReturnNoPara(this.DoNothing);
method += new NoReturnNoPara(DoNothingStatic);
method += new NoReturnNoPara(Student.StudyAdvanced);
method += new NoReturnNoPara(new Student().Study);
method += new NoReturnNoPara(student.Study);
method.Invoke();

Console.WriteLine("***下面是多播委托移除方法***");
//-= 为委托实例移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的，移除且只移除一个，没有也不异常
method -= new NoReturnNoPara(this.DoNothing);
method -= new NoReturnNoPara(DoNothingStatic);
method -= new NoReturnNoPara(Student.StudyAdvanced);//不是同一个实例，所以是不同的方法
method -= new NoReturnNoPara(student.Study);
method.Invoke();

查看运行结果：

从运行结果中可以看出上面的原因是正确的。

注意：多播委托不能异步调用(即调用BeginInvoke())，因为多播委托里面有很多方法，异步调用的时候不知道该怎样执行，是把所有方法同步执行呢还是按照顺序依次执行呢，BeginInvoke不知道该如何调用，所以多播委托不能直接调用BeginInvoke()方法。那如果我想使用该怎么办呢？可以使用GetInvocationList()方法，F12查看GetInvocationList()方法的定义：

那么可以使用如下的代码：

foreach(NoReturnNoPara item in method.GetInvocationList())
{
      item.Invoke();
}

上面的多播委托例子中一直都是使用的没有返回值的委托，如果是有返回值的委托，那么返回值是什么呢？请看下面的例子：

先定义几个有返回值的方法：

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

实例化委托：

WithReturnNoPara methodWithReturn = new WithReturnNoPara(this.GetSomething);
methodWithReturn += new WithReturnNoPara(this.GetSomething2);
methodWithReturn += new WithReturnNoPara(this.GetSomething3);
int iResult = methodWithReturn.Invoke();
Console.WriteLine("返回值:"+iResult.ToString());

运行程序查看结果：

从截图中可以看出：带返回值的多播委托的结果是最后添加的方法的返回值。中间方法的返回值都会被丢弃。

总结：多播委托一般用来调用无返回值的方法，不用来调用有返回值的方法，因为有返回值的多播委托中间的结果都会被丢弃掉。

总结

我们可以对委托做如下的总结：

委托是不可变的。
使用+=或-=操作符时，实际上是创建了新的委托实例，并把它赋给当前的委托变量。
如果多播委托的返回类型不是void，那么调用者从最后一个被调用的方法来接收返回值，前面的方法仍然会被调用，但是其返回值就被弃用了。
所有的委托类型都派生于System.MulticastDelegate，而它又派生于System.Delegate。
C#会把作用于委托的+、-、+=、-=操作编译成使用System.Delegate的Combine和Remove两个静态方法。

二、事件

1、什么是事件

事件是带event关键字的委托的实例。

2、如何声明事件

// 声明委托
public delegate void MiaoDelegate();
// 声明事件
public event MiaoDelegate MiaoDelegateHandlerEvent;

3、委托和事件的区别和联系

委托是一个类型，例如Student类。

事件是委托类型的一个实例，例如具体的一个学生。

4、为什么要是有事件

事件不能直接执行Invoke()方法，可以限制变量被外部调用或者直接赋值。

注意：即使是在子类中，事件也不能调用Invoke()方法。

三、委托和事件的应用

来看下面的一个例子：

有一个Cat类，里面有一个Miao()的方法，猫叫了一声，然后触发一系列的后续动作，通常的实现代码如下：

public void Miao()
{
     Console.WriteLine("{0} Miao", this.GetType().Name);

      new Mouse().Run();
      new Baby().Cry();
      new Mother().Wispher();
      new Father().Roar();
      new Neighbor().Awake();
      new Stealer().Hide();
      new Dog().Wang();
}

调用Miao()方法：

// 实例化
Cat cat = new Cat();
cat.Miao();

上面的代码可以实现上述的需求，但是这段代码耦合性很强，因为是在Miao()方法里面直接调用别的实例的方法，以后无论是增加或者修改、调整方法的调用顺序，都要修改Miao()方法，使得Miao()方法不稳定。

下面使用委托来优化上面的代码：

// 声明委托
public delegate void MiaoDelegate();
public MiaoDelegate MiaoDelegateHandler;
public void MiaoNew()
{
     Console.WriteLine("{0} MiaoNew", this.GetType().Name);
     if (this.MiaoDelegateHandler != null)
     {
          this.MiaoDelegateHandler.Invoke();
     }
}

调用：

Cat cat = new Cat();
// 多播委托
cat.MiaoDelegateHandler += new MiaoDelegate(new Mouse().Run);
cat.MiaoDelegateHandler += new MiaoDelegate(new Baby().Cry);
cat.MiaoDelegateHandler += new MiaoDelegate(new Mother().Wispher);
cat.MiaoDelegateHandler += new MiaoDelegate(new Brother().Turn);
cat.MiaoDelegateHandler += new MiaoDelegate(new Father().Roar);
cat.MiaoDelegateHandler += new MiaoDelegate(new Neighbor().Awake);
cat.MiaoDelegateHandler += new MiaoDelegate(new Stealer().Hide);
cat.MiaoDelegateHandler += new MiaoDelegate(new Dog().Wang);
cat.MiaoNew();

上面的委托也可以改为事件实现：

// 声明事件
public event MiaoDelegate MiaoDelegateHandlerEvent;
public void MiaoNewEvent()
{
     Console.WriteLine("{0} MiaoNewEvent", this.GetType().Name);
     if (this.MiaoDelegateHandlerEvent != null)
     {
          this.MiaoDelegateHandlerEvent.Invoke();
     }
}

调用：

Cat cat = new Cat();
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Mouse().Run);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Baby().Cry);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Mother().Wispher);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Brother().Turn);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Father().Roar);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Neighbor().Awake);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Stealer().Hide);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Dog().Wang);
cat.MiaoNewEvent();

到此这篇关于C#委托和事件的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持得得之家。