unity的C#学习——委托事件和匿名方法
Posted 时生丶
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了unity的C#学习——委托事件和匿名方法相关的知识，希望对你有一定的参考价值。
文章目录
C# 委托
委托是C#编程语言中的一个重要特性，它是一种类似于函数指针的引用类型变量，它可以存储对一个或多个方法的引用。
- 委托是一种类型安全的“函数指针”，因为它会对被引用方法的签名和返回类型进行检查，确保方法参数和返回值类型与委托定义的一致。
委托可以在运行时被动态地改变，使得我们可以将方法作为参数进行传递，以及在需要时动态地调用它们，从而实现回调、事件处理和异步编程等功能。
1、委托的声明
在 C# 中，委托是一种引用类型变量，它的声明使用 delegate 关键字，其语法格式为：
<访问修饰符> delegate <返回类型> <委托名称>([参数列表]);
其中：
- 访问修饰符是可选项，表示委托的访问级别，默认为
internal； - 返回类型表示委托所引用方法的返回类型；
- 委托名称是对委托类型的命名；
- 参数列表包含一个或多个参数，这些参数的类型和数量必须与委托所引用的方法的参数列表相同。
例如，下面是声明一个简单的委托类型的示例：
delegate void MyDelegate(string name);
该委托类型可以引用一个参数为字符串类型、无返回值的方法。上述委托的访问等级为默认的 internal，这意味着仅同一个程序集内的其他代码可以访问该委托类型，但是在程序集之外的代码则不能直接访问该委托类型。
2、委托的实例化
委托的使用可以分为以下几步：
- 声明委托类型：使用delegate关键字声明一个委托类型，指定委托可以引用的方法的参数列表和返回值类型。
- 实例化委托对象：使用委托类型实例化一个委托对象，将该委托对象引用一个或多个方法。
- 调用委托：调用委托对象可以调用其所引用的方法。
一旦声明了委托类型，委托对象需要使用 new 关键字来创建，且与一个特定的方法有关。当创建委托时，传递到 new 语句的参数就像方法调用一样书写，但是不需要在创建时传递参数。例如：
public delegate void printString(string s);
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);
以下是委托的声明、实例化并调用的示例代码：
using System;
// 声明一个委托类型
delegate int Calculate(int a, int b);
class Program
static int Add(int a, int b)
return a + b;
static int Multiply(int a, int b)
return a * b;
static void Main(string[] args)
// 创建委托实例，并将其指向Add方法
Calculate calc = Add;
// 使用委托调用Add方法
int result = calc(3, 5);
Console.WriteLine(result); // 输出 8
// 将委托实例重新指向Multiply方法
calc = Multiply;
// 使用委托调用Multiply方法
result = calc(3, 5);
Console.WriteLine(result); // 输出 15
在这个示例中，我们首先声明了一个委托类型 Calculate，其定义了一个接收两个 int 参数并返回一个 int 类型值的方法签名。
然后，我们定义了两个静态方法 Add 和 Multiply，用于执行加法和乘法运算。接下来，我们创建了一个委托实例 calc 并将其指向 Add 方法，然后使用 calc 调用了 Add 方法并输出结果。接着，我们将 calc 重新指向 Multiply 方法，并再次使用 calc 调用了 Multiply 方法并输出结果。
补充：委托实例化的快捷方式
using System;
delegate void MyDelegate(string message);
MyDelegate d1 = Method1; //这种语法，是委托实例化的一种快捷方式，与下方等价
MyDelegate d1 = new MyDelegate(Method1);
需要注意的是，这种快捷方式只适用于将委托实例化为一个方法的情况。对于需要使用 new 语法实例化的其他类型，不能使用这种快捷方式。例如，如果要实例化一个自定义类的对象，仍然需要使用完整的 new 语法。
3、System.Delegate类
System.Delegate 是所有委托类型的基类，它提供了一些有用的方法，使得对委托的使用更加方便。以下是System.Delegate 类的一些主要功能：
-
Combine：用于将两个委托合并成一个新的委托，使得调用新的委托时，会依次调用原始的两个委托。例如，可以使用Combine方法将两个事件处理方法组合成一个委托，用于处理事件。 -
Remove：用于从一个委托中移除另一个委托。如果将一个委托从另一个委托中移除后，调用新的委托时就不会调用移除的委托了。 -
Equals：用于比较两个委托是否相等。如果两个委托调用的是同一个方法，它们就是相等的。 -
GetInvocationList：用于获取一个委托中引用的所有方法的列表。如果一个委托包含多个方法，可以使用GetInvocationList方法获取它们的列表。
下面是关于委托的示例代码，演示了 Combine、Remove、Equals、GetInvocationList 方法的用法：
using System;
delegate void DelegateType();
class Program
static void Main(string[] args)
DelegateType handler1 = new DelegateType(Method1);
DelegateType handler2 = new DelegateType(Method2);
DelegateType handler3 = new DelegateType(Method3);
// Combine two delegates
DelegateType combined = handler1 + handler2;
Console.WriteLine("Combined delegate calls:");
combined();
// Remove a delegate
combined -= handler2;
Console.WriteLine("Combined delegate after removal:");
combined();
// Check if two delegates are equal
bool equals = handler1.Equals(combined);
Console.WriteLine($"handler1 equals combined? equals");
// Get an array of invocation list delegates
Delegate[] invocationList = combined.GetInvocationList();
Console.WriteLine("Invocation list:");
foreach (Delegate del in invocationList)
del.DynamicInvoke();
static void Method1()
Console.WriteLine("Method 1 called.");
static void Method2()
Console.WriteLine("Method 2 called.");
static void Method3()
Console.WriteLine("Method 3 called.");
输出结果为：
Combined delegate calls:
Method 1 called.
Method 2 called.
Combined delegate after removal:
Method 1 called.
handler1 equals combined? True
Invocation list:
System.DelegateType Method1()
除此之外，System.Delegate 还提供了一些与安全性相关的方法，如 DynamicInvoke 和 DynamicInvokeImpl ，这些方法允许在运行时动态地调用委托，并检查调用的方法是否具有正确的参数和返回类型。
4、委托的高级特性
主要介绍一下委托的多播、匿名委托和 Lambda 表达式。
4.1 委托的多播能力
在C#中，委托还具有多播（Multicast）能力，即一个委托对象可以包含多个方法的引用，可以将多个委托对象合并为一个委托对象，并一次性调用所有包含的方法。这使得委托在事件处理中尤其有用，因为多个方法可以同时响应同一个事件。
- 要创建一个多播委托，可以使用
"+="运算符将一个委托与另一个委托连接起来，形成一个包含多个方法引用的新委托。类似地，使用"-="运算符可以将委托从多播委托中移除。 - 此外也可以使用上一部分提到的
Combine和Remove两个方法。
以下是一个简单的示例代码，演示了如何创建、合并和移除委托的多播链：
using System;
delegate void MyDelegate(string message);
class Program
static void Main(string[] args)
MyDelegate d1 = Method1;
MyDelegate d2 = Method2;
MyDelegate d3 = Method3;
MyDelegate d = d1 + d2 + d3; // 创建多播委托
d("Hello, world!"); // 调用多播委托
d = d - d2; // 移除 d2 委托
d("Hello again!"); // 调用修改后的多播委托
static void Method1(string message)
Console.WriteLine("Method1 says: " + message);
static void Method2(string message)
Console.WriteLine("Method2 says: " + message);
static void Method3(string message)
Console.WriteLine("Method3 says: " + message);
这段代码的运行结果为：
Method1 says: Hello, world!
Method2 says: Hello, world!
Method3 says: Hello, world!
Method1 says: Hello again!
Method3 says: Hello again
4.2 匿名委托和Lambda表达式
匿名委托和Lambda表达式是两种创建委托实例的方式。
- 匿名委托是指在创建委托实例时，不需要先定义一个方法，而是直接在实例化委托的过程中定义一个匿名方法。匿名委托的语法类似于定义一个方法，但不需要方法名，而是在后面跟上方法体。例如：
delegate int Calculate(int x, int y);
// 创建匿名委托实例
Calculate calc = delegate (int x, int y)
return x + y;
;
- Lambda表达式是一种更为简洁的匿名方法写法，它可以把一个方法体压缩成一行代码，并且省略掉参数类型和返回类型的声明。Lambda表达式的语法是：
参数列表 => 方法体，例如：
// 创建Lambda表达式委托实例
Calculate calc = (x, y) => x + y;
Lambda 表达式的优势在于可以大大简化代码，让代码更加易读和易懂。此外，Lambda 表达式也支持 LINQ 等一些强大的功能。
C# 事件
在 C# 中，事件是一种特殊的委托，它允许一个对象在发生某个特定的动作或状态改变时，通知其他对象对这个事件进行响应和处理。例如，当用户点击一个按钮时，系统会触发一个 Click 事件，应用程序可以通过响应该事件来实现对用户的操作。
事件机制的作用在于实现对象间的解耦，也就是将事件的发布者和订阅者解耦。事件让发布者不需要知道谁或哪些对象对事件感兴趣，也不需要直接调用特定的对象或函数来响应事件。事件只需要向外部通知事件发生即可，而订阅者需要注册事件处理器来响应事件。这样一来，发布者与订阅者之间就可以保持独立，且可以随意变换，使得代码更加灵活、可维护性更高。
1、事件的声明和使用
在 C# 中，声明和使用事件通常需要以下步骤：
1.1 定义事件委托类型
事件委托类型定义了事件处理q器的方法签名（包括方法的名称、返回类型以及参数类型和顺序等信息）。在 C# 中，可以使用 delegate 关键字定义事件委托类型。例如，以下代码定义了一个事件委托类型 EventHandler：
public delegate void EventHandler(object sender, EventArgs e);
这个委托类型有两个参数：
- 一个是
object类型的sender，用于指示事件的来源； - 另一个是
EventArgs类型的e，用于传递事件的附加信息。
在使用事件时，可以使用这个委托类型作为事件的类型。
1.2 声明事件
在一个类中声明一个事件，需要使用 event 关键字和事件委托类型。例如，以下代码声明了一个名为 ButtonClick 的事件：
public event EventHandler ButtonClick;
这个事件使用了之前定义的 EventHandler 委托类型。注意，在事件的使用中委托不再被视为引用变量，而是被视为一种特殊的数据类型，所以声明事件也叫创建委托类型的变量。
- 具体来说，事件是委托类型的实例，它具有和委托类型相同的特性，包括可以添加或移除多个委托实例，触发委托实例等。
- 当我们声明一个事件时，实际上就是在声明一个委托类型的变量，然后使用关键字
event修饰它，使得它只能在类内部被访问并且只能被用于绑定方法。
1.3 触发事件
触发一个事件的通常做法是通过调用事件的委托变量来实现的。具体来说，事件触发器（包含触发语句的一个方法）将检查事件的委托变量是否为 null，如果不为 null，则调用委托变量。通常使用 Invoke 方法来调用委托变量。
例如，以下代码触发了 ButtonClick 事件：
ButtonClick?.Invoke(this, EventArgs.Empty);
其中：
Invoke()是一个委托类型的方法，用于执行指定的委托。我们之前说的调用委托对象来调用其所引用的方法，底层就是使用了Invoke()方法。ButtonClick事件的类型为EventHandler，它是一个委托类型，定义了接受两个参数（object sender, EventArgs e）且返回类型为void的方法。因此：this表示将事件源作为参数传递给这些方法；EventArgs.Empty表示将空的EventArgs对象传递给这些方法，即不传递附加信息。
?.是我们之前提到的可空运算符，表示当ButtonClick为 null 时不调用其Invoke方法。
当然也并非一定要使用上述方法触发事件，也可以写成下面的格式：
if ( ChangeNum != null )
ButtonClick(this, EventArgs.Empty); // 事件被触发
else
Console.WriteLine( "event not fire" );
Console.ReadKey(); // 回车继续
1.4 实现事件处理器
事件处理器是一个方法，实现该方法时，需要遵循事件委托类型定义的方法签名，这里主要指该方法的返回类型、参数类型及顺序需要与委托类型定义的相同。
例如，以下代码实现了一个名为 OnButtonClick 的事件处理器：
// 事件处理器
private void OnButtonClick(object sender, EventArgs e)
// 处理事件
在事件处理器中，可以编写处理事件的代码。其中，sender 参数表示事件的来源，e 参数表示事件的附加信息。
1.5 添加和移除事件处理器
在使用事件时，可以添加和移除事件处理器。
例如，以下代码通过 += 运算符，添加了一个名为 OnButtonClick 的事件处理器：
ButtonClick += OnButtonClick;
这个代码将 OnButtonClick 方法添加到 ButtonClick 事件的事件处理器列表中。要从事件处理器列表中移除事件处理器，可以使用 -= 运算符：
ButtonClick -= OnButtonClick;
这个代码将 OnButtonClick 方法从 ButtonClick 事件的事件处理器列表中移除。
2、通过事件使用委托的案例
事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理器关联。包含事件的类用于发布事件，被称为 发布器（publisher） 类。其他接受该事件的类被称为 订阅器（subscriber） 类。事件使用 发布-订阅（publisher-subscriber） 模型。
-
发布器（publisher） 是一个包含事件（和委托）定义的对象。事件和委托之间的联系也定义在这个对象中。发布器（publisher）类的对象通过事件触发器调用这个事件，并通知其他的对象。
-
订阅器（subscriber） 是一个接受事件并提供事件处理器的对象。在发布器类中触发事件后，调用订阅器类中处理事件的方法。
下列代码演示了如何定义事件，如何订阅事件以及如何触发事件：
using System;
namespace EventDemo
// 定义一个委托类型，用于处理事件（也可以把它定义在发布器类中）
public delegate void EventHandler(object sender, EventArgs args);
// 定义一个发布器类，它会触发事件
public class Publisher
// 定义事件
public event EventHandler MyEvent;
// 触发事件的方法
public void RaiseEvent()
Console.WriteLine("事件被触发了！");
// 检查是否有订阅者（ MyEvent是否为null），如果有则调用其事件处理器
MyEvent?.Invoke(this, EventArgs.Empty);
// 定义一个订阅器类，它会接收事件
public class Subscriber
// 事件处理方法，需要和委托类型定义的签名一致
public void HandleEvent(object sender, EventArgs args)
Console.WriteLine("事件被处理了！");
class Program
static void Main(string[] args)
// 创建一个发布器实例
Publisher pub = new Publisher();
// 创建一个订阅器实例
Subscriber sub = new Subscriber();
// 订阅事件
pub.MyEvent += sub.HandleEvent;
// 触发事件
pub.RaiseEvent();
Console.ReadKey();
上述代码中，判断事件的委托变量 MyEvent 是否为 null ，其实就是在判定创建该变量后，有没有通过 += 订阅事件，为事件的委托变量添加可引用的事件处理器。同时因为事件在发布器内部是作为一个委托类型的变量被定义的，所以在类的外部要通过 实例名.事件名 来访问。
运行上面的代码会产生如下结果：
事件被触发了！
事件被处理了！
下面是一个简单的用于热水锅炉系统故障排除的应用程序，用于展示事件和委托的实际应用场景。当维修工程师检查锅炉时，锅炉的温度和压力会随着维修工程师的备注自动记录到日志文件中：
using System;
using System.IO;
namespace BoilerEventAppl
// 锅炉类
class Boiler
private int temp; // 锅炉温度
private int pressure; // 锅炉压力
// 构造函数，初始化温度和压力
public Boiler(int t, int p)
temp = t;
pressure = p;
// 获取锅炉温度
public int getTemp()
return temp;
// 获取锅炉压力
public int getPressure()
return pressure;
// 事件发布器类
class DelegateBoilerEvent
// 声明一个委托类型，用于指向处理 BoilerLog 事件的方法
public delegate void BoilerLogHandler(string status);
// 声明 BoilerLog 事件，事件类型为 BoilerLogHandler 委托
public event BoilerLogHandler BoilerEventLog;
// 发布 BoilerLog 事件，处理日志信息
public void LogProcess()
string remarks = "O. K";
Boiler b = new Boiler(100, 12);
int t = b.getTemp();
int p = b.getPressure();
// 判断锅炉温度和压力是否正常，如果不正常，需要进行维修
if (t > 150 || t < 80 || p < 12 || p > 15)
remarks = "Need Maintenance";
// 发布 BoilerLog 事件，传递日志信息
OnBoilerEventLog("Logging Info:\\n");
OnBoilerEventLog("Temparature " + t + "\\nPressure: " + p);
OnBoilerEventLog("\\nMessage: " + remarks);
// 触发 BoilerLog 事件，调用事件委托
protected void OnBoilerEventLog(string message)
if (BoilerEventLog != null)
BoilerEventLog(message);
/* 也可以写成：BoilerEventLog?.Invoke(message); */
// 该类保留写入日志文件的条款
class BoilerInfoLogger
FileStream fs;
StreamWriter sw;
// 构造函数，打开日志文件
public BoilerInfoLogger(string filename)
fs = new FileStream(filename, FileMode.Append, FileAccess.Write);
sw = new StreamWriter(fs);
// 将日志信息写入文件
public void Logger(string info)
sw.WriteLine(info);
// 关闭日志文件
public void Close()
sw.Close();
fs.Close();
// 事件订阅器类
public class RecordBoilerInfo
// 定义一个处理 BoilerLog 事件的方法，输出日志信息到控制台
static void Logger(string info)
Console.WriteLine(info);
static void Main(string[] args)
// 创建一个文本日志记录器
C#学习之初步理解委托事件匿名方法和Lambda
最经在学习LinqtoSql，然后扯到Lambda表达式，然后扯到匿名方法，然后扯到委托，最后扯到事件处理。。。后来发现对委托这个概念和事件处理这个过程理解得不是很清晰，遂得一下学习笔记。那里说得不对，请大家多多指教！
第一部分：理解委托
委托委托，顾名思义，就是类似于中间人的意思，有些事情你不做，委托别人去做，比如你想相亲，但你不想去主动约女孩子，那你可以交给媒婆去帮你约。
如果你学过C++，请把委托理解成函数指针，都是为了调用函数。函数指针可以调用符合该函数指针要求的函数。什么叫符合该函数指针要求？就是被调用的函数拥有和该函数指针一样的返回类型、参数的个数相同、对应参数的类型一致。
函数指针举例说明。int (*p)(int,int);定义了一个函数指针p,p只能调用 函数原型（或者说函数签名）是 返回类型为int、只有两个参数并且参数类型都是int的函数。
委托举例说明：delegate void MyDelegate(int a,int b);声明了一种委托类型 MyDelegate（委托有不同类型，就好像中间人有不同类型，你想相亲就找媒婆这种中间人，你想看风水，就找风水大师这种中间人），这种委托类型只能调用 返回类型是void、只有两个参数并且参数类型都是int的函数。跟函数指针是不是很像？
委托其实就是一个类，委托的基类是Delegate 类，只不过我们不能显示地从 Delegate 类派生出委托类（Delegate 类不是委托类型，它的派生类才是），这是给系统和编译器用的。只不过类实例化之后就叫对象，而委托实例化之后还是叫委托而已，另外实例化委托必须提供一个相对应的函数作为参数。
举例说明定义委托：（参考自：http://www.cnblogs.com/warensoft/archive/2010/03/19/1689806.html）
1、定义一个函数Max，函数签名位：返回类型为int，两个参数，参数类型都是int
int Max(int x,int y) {return x>y?x:y;}
2、创建一个委托类型（名字是MyDelegate），并声明该委托类型可以调用的函数的函数原型（函数签名）为：返回类型为int，两个参数，参数类型都是int。注意，委托是一个类，创建委托类型要放在函数外面
delegate int MyDelegate(int a,int b);
3.建立一个委托类的实例（或者说MyDelegate的实例），并指向要调用的方法，有两种方式：
//利用委托类的构造方法指定，这是最为常见的一种方式
MyDelegate md = new MyDelegate(Max);
//利用自动推断方式来指明要调用的方法，该形式更类型于函数指针
MyDelegate md = Max;
用第一种方式创建委托实例时必须提供一个函数签名符合该委托类型的函数作为参数。
4、利用委托类实例调用所指向的方法
int c = md(4,5);
总结：可以把委托理解成函数指针，可以调用函数签名和委托类型一致的函数
第二部分：事件处理（本文主要想表达对委托的理解，所以这部分以后再详说）
事件处理涉及到两个对象：一个是事件源（就是触发该事件的对象），另一个是事件接收者（提供了处理方法的类）。两者本无联系。
事件处理的过程：首先事件源触发了某事件，委托捕获到这件事（委托通过订阅该事件实现），委托调用事件接收类中的相应函数进行处理。
举例说明：this.button1.Click += new System.EventHandler(this.button1_Click);
事件源是button1，触发的事件是 按钮单击事件 Click，委托是 System.EventHandler ，事件处理函数是 button1_Click 。上面代码的意思是，System.EventHandler （委托）对 this.button1（事件源）的 Click （事件） 进行订阅，当this.button1 的Click事件发生时，委托接收事件源传过来的一些参数，接着调用 this.button1_Click (事件处理函数) 并把从事件源那里接收的参数传给该函数作为参数。
第三部分：匿名方法
匿名方法就是没有名字的方法（函数），既然没有名字，就是说只有在定义的时候能调用，在其他地方就不能调用了（没有名字啊，那就找不到嘛）。为什么 要用到匿名方法呢？调用函数是需要花销的，但有时候调用的一些方法很短小（例如一句话方法）、只完成很少的功能，这个时候就有点得不偿失了，此时就可以定 义一个匿名方法来完成这个功能了，而匿名方法作为内联代码，花销相对小很多。匿名方法都是和委托连在一起用的（以后还有lambda表达式），以前创建委 托实例时需要传递一个函数名给它作为参数，现在可以通过匿名方法直接把一段代码传进去了
定义匿名方法：用到delegate关键字，如：delegate(int a, int b){return a > b ? a : b ;} 代码定义了一个匿名方法，该方法的参数是 int a 和 int b ，方法体是 {return a > b ? a : b}。如果只是定义一个匿名方法没有意义，因为定义完过后你就再也不能用这个匿名方法，所以匿名方法要在定义的时候就马上使用。一般来说就是初始化委托 了。
使用匿名方法：
1 namespace DelegateTest
2 {
3 class Program
4 {
5 //创建委托类型
6 delegate int Mydelegate(int x, int y);
7 static void Main(string[] args)
8 {
9 //创建委托实例，指向匿名函数
10 Mydelegate mydelegate = delegate(int x,int y) { return x + y; };
11
12 //通过委托调用匿名方法
13 Console.WriteLine(mydelegate(3,2));
14
15 Console.ReadKey();
16 }
17 }
18 }
总结：匿名方法就是没有名字的方法，只能通过委托来被调用（这句话可能有误，匿名方法也可以直接订阅事件作为事件处理函数，当事件发生时就接收相应参数并执行函数体）。
第四部分：Lambda
上面说到可以通过匿名方法以内联代码的方式来简介地实现委托，但还有更简洁的方法，那就是用lambda表达式来代替匿名方法，在这里，lambda表达式就是匿名方法的简洁版。
Lambda表达式的语法如下：
(param1, param2 ...,paramN) =>
{
表达式1;
表达式2;
return 返回值;
}
param1, param2 ...,paramN 就是参数，不用确定类型，编译器会做这个工作，花括号了就是lambda表达式要执行的语句，如果对应的委托类型有返回值，那么就要有return 语句。
把第三部分那个匿名方法的例子改成用lambda表达式实现：
1 namespace DelegateTest
2 {
3 class Program
4 {
5 //创建委托类型
6 delegate int Mydelegate(int x, int y);
7 static void Main(string[] args)
8 {
9 //创建委托实例，指向匿名函数
10 // Mydelegate mydelegate = delegate(int x,int y) { return x + y; };
11
12 //通过委托调用匿名方法
13 // Console.WriteLine(mydelegate(3,2));
14
15 Mydelegate youdelegate = (x, y) => { return (x - y); };
16 Console.WriteLine(youdelegate(3, 2));
17
18 Console.ReadKey();
19 }
20 }
21 }
总结：匿名方法就是没有名字的函数，Lambda表达式就是匿名方法的简洁版（指的是用在委托上这方面，Lambda还有其他方面的用处），两者都只是让代码更简洁，但在更底层层次本质是一样的
以上是关于unity的C#学习——委托事件和匿名方法的主要内容，如果未能解决你的问题，请参考以下文章
转UNITY3D 游戏开发之七C# 中的委托事件匿名函数Lambda 表达式
C#委托，匿名方法，Lambda，泛型委托，表达式树代码示例