【Unity|C#】基础篇(8)——委托（Delegate）/ 事件（Event）

2022-09-29 18:43:59

【学习资料】

　　《C#图解教程》（第13~14章）：https://www.cnblogs.com/moonache/p/7687551.html
　　电子书下载：https://pan.baidu.com/s/1mhOmBG0

其他

　　　　> 委托与事件详解Part1：http://www.tracefact.net/tech/009.html

　　　　> 委托与事件详解Part2：http://www.tracefact.net/tech/029.html

【内容】

- 委托（Delegate）
  - 定义：类似C++的函数指针
  - 委托多播
  - 委托绑定函数及执行原理
- 事件（Event）
  - 定义：类似字段与属性的关系
  - 事件访问器（add/remove）
  - 为什么使用事件?

【委托Delegate】

定义

类似C++的函数指针，delegate相当于是指向某对象的某个函数，的引用类型变量
委托和类一样，也需要声明、创建、赋值
- 声明委托类型（像类一样声明一个委托类型） public delegate [函数返回值] 委托名称(参数1，参数2...);
- 创建委托变量 MyDelegate opt = new MyDelegate(AddNum); （实际绑定的是：this.AddNum）
- 重新赋值 opt = MultNum; （实际绑定的是：this.MultNum）
执行委托：就是执行引用的委托函数
委托可以：动态修改引用的函数

// 声明：一个可以指向 返回类型为int，带2个int参数的 函数

public delegate int MyDelegate(int a, int b);

// 相加函数

public int AddNum(int a, int b)

{

    return (a + b);

}

// 相乘函数

public int MultNum(int a, int b)

{

    return (a * b);

}

void Start()

{
// 创建：指向不同函数的委托类型

    MyDelegate opt = new MyDelegate(AddNum);

    Debug.Log(opt(, )); // 执行委托函数: 7

    // 运行时，可以改变赋值

    opt = MultNum;

    Debug.Log(opt(, )); // 执行委托函数: 10

}

委托多播

创建的委托类型变量 opt 可以存储 函数调用列表（绑定多个委托函数）
通过 "+"，或"+="：添加一个函数引用
通过 "-"，或"-=" ：移除某个函数的引用
执行委托：会执行所有添加绑定的委托函数

public delegate void MyDelegate(int a, int b);

// 输出相加结果

public void PrintAddNum(int a, int b)

{

    Debug.Log("PrintAddNum:" + (a + b));

}

// 输出相乘结构

public void PrintMultNum(int a, int b)

{

    Debug.Log("PrintMultNum:" + (a * b));

}

void Start()

{

    // 创建：指向不同函数的委托类型

    MyDelegate opt = new MyDelegate(PrintAddNum);

    // 通过+=添加委托函数

    // 也可以直接相加 opt = PrintAddNum + PrintMultNum;

    opt += PrintMultNum;

    // 执行委托，会按添加的顺序，分别执行PrintAddNum和PrintMultNum

    opt(, );

    // 通过-=移除对某函数的引用

    opt -= PrintAddNum;

    // 再次执行委托，只执行了PrintMultNum

    opt(, );

}

// 输出

//  PrintAddNum: 7

//  PrintMultNum: 10

//  PrintMultNum: 10

委托绑定函数及执行原理

绑定委托函数

可以通过：“=”、“+=”、“-=”、“+”、“-”，来重新给委托绑定函数，或添加删除函数
绑定普通函数：同时会将对象（this）引用存储起来
绑定静态函数：无需存储对象（this）引用

class Person

{

    public delegate void MyDelegate(int a, int b);

    public MyDelegate myDelegate;

    // 普通函数，绑定时需要有明确对象(this)

    public void Func1(int a, int b) { ... }
// 静态函数，通过类名.Func2绑定

    public static void Func2(int a, int b) { ... }

}

void Start()

{

    Person myPerson = new Person();

    //myPerson.myDelegate += Person.Func1;  // 报错，Func1需要对象(this)

    myPerson.myDelegate += Person.Func2;

    myPerson.myDelegate += myPerson.Func1;

    //myPerson.myDelegate += myPerson.Func2; // 报错，Func2是静态函数

}

执行方式

通过"+" 或 "+=" 的顺序，依次执行绑定的委托函数
普通函数：相当于调用绑定对象引用（this）的函数，包含了对象的this引用
静态函数：相当于调用绑定的委托函数；

// 声明委托类型

public delegate void MyDelegate();

class Person

{

    public string name;

    public void PrintName()

    {

        Debug.Log(name);

    }

}

void Start()

{

    // 创建2个对象

    Person myPerson = new Person();

    Person myPerson2 = new Person();

    myPerson.name = "Alice";

    myPerson2.name = "Bob";

    // 创建委托变量

    MyDelegate myDelegate = new MyDelegate(myPerson.PrintName);

    // 多播：委托函数

    myDelegate += myPerson2.PrintName;

    // 执行委托

    myDelegate();

}

// 输出

//  Alice

//  Bob

【事件】

定义

事件是对委托的封装，关系和字段与属性(Property) 一样
事件是基于委托，所以首先要声明委托，再定义事件

// 声明委托类型

public delegate void MyDelegate(int a, int b);

// 定义事件

public event MyDelegate myEvent;

注：事件的声明只能在类内部，不能在函数内
原理
- 实际上与属性一样，定义一个事件，会自动创建一个隐藏(private)的委托类型变量
- 并包含了add_xxx（"+="）和remove_xxx（"-="），用来添加/删除委托函数
事件的执行：只能在定义事件的类内部执行

// 声明委托类型

public delegate void MyDelegate(int a, int b);

class Person

{

    // 定义事件

    public event MyDelegate myEvent;

    public void FireEvent(int a, int b)

    {

        if (myEvent != null)

            myEvent(a, b); // 必须在定义事件的类内部执行

    }

}

public void PrintAddNum(int a, int b)

{

    Debug.Log("PrintAddNum:" + (a + b));

}

public void PrintMultNum(int a, int b)

{

    Debug.Log("PrintMultNum:" + (a * b));

}

void Start()

{

    Person person = new Person();

    person.myEvent += PrintAddNum;

    person.myEvent += PrintMultNum;

    //person.myEvent(2, 5); // 报错，无法在定义事件的类外部执行

    person.FireEvent(, ); // 正确

}

注：事件不能在类的外部使用赋值“=”，但是在类内部可以重新赋值“=”
事件与委托一样，也支持多播：可以通过“+=”、“-=” 来添加事件、删除事件

事件访问器（add / remove）

事件与委托的关系，与字段与属性的关系是一样的，所以也有访问器
关键字： add remove

public event MyDelegate myEvent

{

    add

    {

        ...    //执行 += 运算符的代码

    }

    remove

    {

        ...    //执行 -= 运算符的代码

    }

}

为什么使用事件？

对委托的封装
- 对外只能通过事件来 添加/删除 绑定的委托函数
- 事件只能在定义事件的 类内部执行
满足观察者模式（发布者-订阅者）

当然不使用事件，也可以实现对委托的封装

将委托定义为private，然后对外提供添加/删除委托函数的方法（相当于手动实现事件中的add_xxx和remove_xxx）

// 声明委托类型

public delegate void MyDelegate(int a, int b);

class Person

{

    // 定义一个私有委托变量

    public MyDelegate myDelegate;

    // 添加

    public void AddEvent(MyDelegate d)

    {

        myDelegate += d;

    }

    // 删除

    public void RemoveEvent(MyDelegate d)

    {

        myDelegate -= d;

    }

    // 执行

    public void FireEvent(int a, int b)

    {

        if (myDelegate != null)

            myDelegate(a, b); // 必须在定义事件的类内部执行

    }

}

public void PrintAddNum(int a, int b)

{

    Debug.Log("PrintAddNum:" + (a + b));

}

public void PrintMultNum(int a, int b)

{

    Debug.Log("PrintMultNum:" + (a * b));

}

void Start()

{

    Person person = new Person();

    person.AddEvent(PrintAddNum);       // this.PrintAddNum

    person.RemoveEvent(PrintMultNum);   // this.PrintMultNum

    person.FireEvent(, );

}

码农公寓

相关文章