C# 委托 Delegate
Delegate 类表示委托，委托是一种数据结构，它引用静态方法或引用类实例及该类的实例方法。
委托的声明、实例化和调用
声明
以下实例声明为Del的委托，该委托采用字符串作为参数，并返回void的方法：
public delegate void Del(string message);
实例化
Delegate的实例化和Class的实例化基本类似。
以下实例是，创建一个Del委托的实例。因为该委托声明是：采用字符串作为参数，并返回void的方法，所以实例化该委托时需要传递一个符号条件的方法作为参数：
Del handler = new Del(DelegateMethod);
上面代码可以简写为以下代码：
Del handler = DelegateMethod;//简写,只写方法就可以，不用使用new关键字
为委托创建一个DelegateMethod 方法（该方法采用字符串作为参数，并返回void）：
void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
调用
调用方式：
Del handler = new Del(DelegateMethod);
handler.Invoke("Hello World");
简写方式（就像将DelegateMethod方法赋值给一个变量，然后通过传递参数的方式执行这个变量）：
Del handler = DelegateMethod;
handler("Hello World");
泛型委托--Func Action
因为委托实际上就是一个方法的类型，所以 .NET Framework根据泛型内置了Action与Func两种形式的委托。
Action
Action是无返回值的泛型委托。
- Action 表示无参，无返回值的委托。如下：
public delegate void Action();
- Action<int,string> 表示有传入参数int,string无返回值的委托
- Action<int,string,bool> 表示有传入参数int,string,bool无返回值的委托
- Action<int,int,int,int> 表示有传入4个int型参数，无返回值的委托
- ·······
Action至少0个参数，至多16个参数，无返回值。
Func
Func是有返回值的泛型委托。
- Func
表示无参，返回值为int的委托
public delegate TResult Func<out TResult>();
- Func<object,string,int> 表示传入参数为object, string 返回值为int的委托
- Func<object,string,int> 表示传入参数为object, string 返回值为int的委托
- Func<T1,T2,,T3,int> 表示传入参数为T1,T2,,T3(泛型)返回值为int的委托
- ·······
Func至少0个参数，至多16个参数，根据返回值泛型返回。必须有返回值，不可void
委托的意义
解耦
例如我们有这样一个需求，有一组学生数据，需要根据条件查询出相应的学生列表，在不使用委托的时候可能我们会写出以下的代码：
学生类：
public class Student
{
public string Name { get; set; }
public int Age { get; set; }
public string Email { get; set; }
public Student(string name, int age, string email)
{
this.Name = name;
this.Age = age;
this.Email = email;
}
public Student() { }
public void Study()
{
Console.WriteLine("我正在学习……");
}
}
实现代码：
List<Student> students = new List<Student>();
students.Add(new Student("Oliver", 18, "123@qq.com"));
students.Add(new Student("小白", 19, "123@sina.com"));
students.Add(new Student("老K", 28, "123@163.com"));
students.Add(new Student("土豆", 16, "232@sina.com"));
students.Add(new Student("番茄", 33, "fanqie@qq.com"));
students.Add(new Student("小红", 22, "24424@163.com"));
students.Add(new Student("黎明", 18, "2232@126.com"));
students.Add(new Student("黄昏", 21, "huanghun@qq.com"));
{
//找出20岁以上的学生
List<Student> newList1 = new List<Student>();
foreach (var item in students)
{
if (item.Age > 20)
{
newList1.Add(item);
}
}
Console.WriteLine("查询到条数：" + newList1.Count);
//找出邮箱长度大于10位的学生
List<Student> newList2 = new List<Student>();
foreach (var item in students)
{
if (item.Email.Length > 10)
{
newList2.Add(item);
}
}
Console.WriteLine("查询到条数：" + newList2.Count);
//找出年龄在20岁以上并且邮箱长度大于10位的学生
List<Student> newList3 = new List<Student>();
foreach (var item in students)
{
if (item.Age > 20 && item.Email.Length > 10)
{
newList3.Add(item);
}
}
Console.WriteLine("查询到条数：" + newList3.Count);
}
经过我们的分析，发现下面的代码在上面重复了3次，都是循环然后进行逻辑判断。
foreach (var item in students)
{
if (....)
{
newList.Add(item);
}
}
然后我们通过使用委托，将逻辑封装到一个方法中，然后将方法传递进去，这样我们就减少耦合：
//定义一个条件委托
delegate bool WhereDelegate(Student s);
//判断年龄是否大于20
bool GetAgeThan(Student s)
{
return s.Age > 20;
}
//判断邮箱长度是否大于10
bool GetEmailLen(Student s)
{
return s.Email.Length > 10;
}
//判断是否年龄在20岁以上并且邮箱长度大于10位
bool GetAgeThanAndEmailLen(Student s)
{
return s.Age > 20 && s.Email.Length > 10;
}
/// <summary>
/// 根据逻辑条件筛选数据
/// </summary>
/// <param name="list">列表</param>
/// <param name="where">逻辑条件</param>
/// <returns>筛选结果</returns>
List<Student> StudentWhere(List<Student> list, WhereDelegate where)
{
List<Student> newList = new List<Student>();
foreach (var item in list)
{
if (where(item))
{
newList.Add(item);
}
}
return newList;
}
调用：
//找出20岁以上的学生
List<Student> newList1 = StudentWhere(students, GetAgeThan);
Console.WriteLine("查询到条数：" + newList1.Count);
//找出邮箱长度大于10位的学生
List<Student> newList2 = StudentWhere(students, GetEmailLen);
Console.WriteLine("查询到条数：" + newList2.Count);
//找出年龄在20岁以上并且邮箱长度大于10位的学生
List<Student> newList3 = StudentWhere(students, GetAgeThanAndEmailLen);
Console.WriteLine("查询到条数：" + newList3.Count);
多播委托
包含多个方法的委托成为多播委托，调用多播委托，可以按照顺序连续调用多个方法。
多播委托可以用运算符"+"和"+="给委托添加方法调用，同样也可以用运算符"-"和"-="给委托删除方法调用
//多播委托
Student s = new Student();
Action action = s.Study;//初始化并添加一个学习的方法
action += s.Sports;//添加一个运动的方法
action();//执行
Console.WriteLine("··············");
action -= s.Sports;//减少一个运动的方法
action();
//输出：
//我正在学习
//我正在运动
//··············
//我正在学习
事件
声明：
public event Action OnSports;//Action 是一个委托
事件：是带event关键字的委托的实例，event可以限制变量被外部调用/直接赋值
事件与委托的区别：
- 委托是一个Class（如Student）
- 而事件是一个委托的实例(如：new Student())
事件与委托实例的区别：
- 事件不能赋值（=）操作，而委托实例可以。
- 事件不能直接调用，如：s.OnSports()，而委托实例可以。
- 事件时一个特殊的委托实例。
我们修改下Student代码，为它添加一个委托的实例对象，一个事件来比较两者的区别：
public class Student
{
public Action OnStudy;//定义了一个委托的实例
public event Action OnSports;//定义了一个事件
public string Name { get; set; }
public int Age { get; set; }
public string Email { get; set; }
public Student(string name, int age, string email)
{
this.Name = name;
this.Age = age;
this.Email = email;
}
public Student() { }
public void Study()
{
if (this.OnStudy != null)
{
this.OnStudy();//调用委托实例
}
Console.WriteLine("我正在学习");
}
public void Sports()
{
if (this.OnSports != null)
{
this.OnSports();//调用事件实例
}
Console.WriteLine("我正在运动");
}
}
在Student外边添加下面代码：
Student s = new Student();
s.OnSports = null;//编译错误，提示：事件“Student.OnSports”只能出现在 += 或 -= 的左边(从类型“Student”中使用时除外)
s.OnSports();//编译错误，提示：事件“Student.OnSports”只能出现在 += 或 -= 的左边(从类型“Student”中使用时除外)
s.OnStudy = null;//正常运行
s.OnStudy();//正常运行