一. 泛型委托
所谓的泛型委托，即自定义委托的参数可以用泛型约束，同时内置委托Func和Action本身就是泛型委托。
将上一个章节中的Calculator类中的方法用自定义泛型委托重新实现一下。
public class Calculator2
{
//传统解决方案一：在该类中声明多个方法，分别是加倍、平方、立方的方法 //传统解决方案二：在该类中声明一个万能方法，通过传递不同的参数类型来区分是执行加倍还是平方或者立方操作 //解决方案三：声明一个万能方法，传递一个委托进来，相当于传递了一个业务逻辑进行，在该方法里只需要执行即可
/// <summary>
/// 万能方法
/// </summary>
/// <param name="arrs">int类型的数组 </param>
/// <param name="mydel">自定义委托</param>
public delegate T myDel<T>(T t);
public static void MySpecMethord<T>(T[] arrs, myDel<T> myDel)
{
for (int i = ; i < arrs.Length; i++)
{
arrs[i] = myDel(arrs[i]);
//arrs[i] = mydel.Invoke(arrs[i]); //等价于上面那句
Console.WriteLine(arrs[i]);
}
} }
二. 内置委托
.Net FrameWork提供两个支持泛型的内置委托,分别是Action和Func,结合lambda表达式,可以提高开发效率
二者的区别：
1.Action只能委托无返回值的方法,支持16个重载(in代表输入参数,该重载没有返回值)
分别是：
* public delegate void Action<in T>(T obj);
* public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
* ......
* public delegate void Action<in T1, in T2,......,in T16>(T1 arg1, T2 arg2,......,T16 arg16);
*
2.Func必须委托有返回值的方法,支持17个重载(注意括号里最后一个代表返回值,in代表输入参数,out代表返回值)
分别是：
* public delegate TResult Func<out TResult>();
* public delegate TResult Func<in T, out TResult>(T arg);
* public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
* ......
* public delegate TResult Func<in T1, in T2,.......in T16 out TResult>(T1 arg1, T2 arg2,......T16 arg16);
*
总结：除了ref参数和out参数，内置委托基本上能适用于任何泛型委托的场景，非常好用
3. 内置委托和自定义委托的区别:
自定义委托需要先声明一下,让系统认识这个自定义委托,然后才能实例化赋值方法；而内置委托系统本事就存在，所有不需要事先声明，直接实例化赋值方法即可
三. 委托的其它性质
静态方法和实例方法对于委托的区别，对于静态方法，Target属性为null，所以效率比实例属性更高
public class OtherCharacters
{
public delegate void mySpecDelegate();
/// <summary>
/// 1.测试普通实例方法和静态方法在委托中的区别
/// </summary>
public static void Test1()
{
MR mr=new MR();
//实例方法
mySpecDelegate a = mr.f1;
Console.WriteLine(a.Target==mr); //true
//静态方法
mySpecDelegate b = MR.f2;
Console.WriteLine(b.Target==null); //true
} } public class MR
{
/// <summary>
/// 普通方法
/// </summary>
public void f1()
{
}
//静态方法
public static void f2()
{ }
}
四. 事件
1. 事件介绍
* 定义：声明一个委托实例,然后在该实例的前面加上event关键字,就形成事件了
* 事件的用途：实现广播和订阅的场景
* 1.广播者：包括1个事件字段,独享执行委托的方法
* 2.订阅者：通过调用 += 和 -= 来决定何时开始或停止订阅
* 总结：事件是描述这种场景模式的一个词,事件是委托的一个子集,为了满足“广播/订阅”模式的需求而生
* 事件和委托的区别：
* 1. 委托是一种类型,而事件是委托的一个实例,然后在该实例前加上一个关键字
* 2. 事件有一系列规则和约束用以保证程序的安全可控，事件只有 += 和 -= 操作，这样订阅者只能有订阅或取消订阅操作，没有权限执行其它操作
* 3. 如果是委托，那么订阅者就可以使用 = 来对委托对象重新赋值（其它订阅者全部被取消订阅），甚至将其设置为null，甚至订阅者还可以直接调用委托，这些都是很危险的操作，广播者就失去了独享控制权
* 4. 事件保证了程序的安全性和健壮性
2. 下面代码就事件和委托进行比较
public class MyEvent
{
//下面的案例用委托和事件实现相同的功能
public Action myDelegate;
/// <summary>
/// 触发委托执行的方法
/// </summary>
public void realizeDelegate()
{
if (myDelegate != null)
{
myDelegate.Invoke();
}
}
public event Action myEvent;
/// <summary>
/// 触发事件执行的方法
/// </summary>
public void realizeEvent()
{
if (myEvent != null)
{
myEvent.Invoke();
}
} #region 供委托和事件测试调用的方法 public static void T1()
{
Console.WriteLine("方法一");
} public static void T2()
{
Console.WriteLine("方法二");
} public static void T3()
{
Console.WriteLine("方法三");
} #endregion }
3. 调用时候的区别：
委托中的订阅者可以直接Invoke()来调用委托，而事件中的订阅者不能直接Invoke()调用委托，只能通过广播者中的方法来实现调用委托，从而保证广播者独享控制权。
{
Console.WriteLine("--------------------------七. 事件------------------------------------");
MyEvent m1 = new MyEvent();
//1. 委托实现
Console.WriteLine("--------------------------1. 委托实现------------------------------------");
//订阅者进行订阅
m1.myDelegate += MyEvent.T1;
m1.myDelegate += MyEvent.T2;
m1.myDelegate += MyEvent.T3;
m1.myDelegate.Invoke(); //委托中的订阅者可以直接调用委托
m1.myDelegate -= MyEvent.T2;
m1.realizeDelegate();
//2. 事件实现
Console.WriteLine("--------------------------2. 事件实现------------------------------------");
m1.myEvent += MyEvent.T1;
m1.myEvent += MyEvent.T2;
m1.myEvent += MyEvent.T3;
// m1.myEvent.Invoke(); //事件中的订阅者不能直接调用委托
m1.realizeEvent(); //只能通过发布者中方法来实现委托，保证发布者独享控制权
m1.myEvent -= MyEvent.T2;
m1.realizeEvent();
}
结果：
