委托在底层就是一个函数的指针，委托是事件的基础。
你可以传递引用类型、值类型、但是你有没有需要传一个方法呢？传方法的过程就是委托。
消息类：
public class Message
{
/// <summary>
/// 传引用类型
/// </summary>
/// <param name="msg"></param>
public static void Send(string msg)
{
Console.WriteLine("你传递的参数是string：{0}", msg);
}
/// <summary>
/// 传值类型
/// </summary>
/// <param name="msg"></param>
public static void Send(int msg)
{
Console.WriteLine("你传递的参数是int：{0}", msg);
}
/// <summary>
/// 利用委托传一个方法过来
/// </summary>
/// <param name="msg"></param>
public static void Send(Action msg)
{
///执行它
msg.Invoke();
// Console.WriteLine("你传递的参数是int：{0}", msg);
}
}
使用例子：
class Program
{
static void Main(string[] args)
{
///传引用类型的字符串
Message.Send("晚上好！端午节快乐！");
///传值类型的，int 68
Message.Send(68);
///传一个方法
Message.Send(SendMessage);
Console.ReadKey();
}
/// <summary>
/// 方法
/// </summary>
static void SendMessage()
{
Console.WriteLine("我是 Program 类的 SendMessage 方法");
}
}
运行结果：
是不是很有用处：
当两个对象之间的处理结果需要相互通知。（onClick，onLoad等一切的事件，基础都是基于委托），委托实际就是一个观察者模式。其作用是两个对象之间可以通过委托，相互通知消息。
委托的定义：
public class DelegateExample
{
/// <summary>
/// 定义一个方法，方法有0到N个参数，可以有返回值，和无返回值
/// </summary>
/// <param name="msg"></param>
public void MethodTest(int Ivalue) { }
/// <summary>
/// 定义另一个委托，委托和方法一样有0到N个参数，可以有返回值，和无返回值
/// </summary>
/// <param name="msg"></param>
/// <param name="msg2"></param>
public delegate int DelegateTest(string msg, string msg2);
public void Show()
{
///定义委托：委托像 “类” 一样，定义来使用，用 new DelegateTest 来指向方法
DelegateTest delegateTest1 = new DelegateTest(DelegateTest2_Mothod);
///调用委托：将参数给定
delegateTest1.Invoke("aa", "bb");
Console.WriteLine("------------------------------------");
///直接指向方法
DelegateTest delegateTest2 = DelegateTest2_Mothod;
///不用 Invoke 也可以直接使用
delegateTest1("cc", "dd");
Console.WriteLine("------------------------------------");
///用 Lambda 表达式来定义一个匿名方法
DelegateTest delegateTest3 = (string msg, string msg2) => { Console.WriteLine("BeginInvoke"); return msg.Length + msg2.Length; };
///异步来调用
delegateTest3.BeginInvoke("ee", "ff", null, null);
Console.WriteLine("------------------------------------");
///用 Lambda 表达式来定义一个匿名方法
DelegateTest delegateTest4 = (string msg, string msg2) => { Console.WriteLine("执行委托"); return msg.Length + msg2.Length; };
///多次指定方法（多播委托）
delegateTest4 += (string msg, string msg2) => { Console.WriteLine("执行委托"); return msg.Length + msg2.Length; };
delegateTest4 += DelegateTest2_Mothod;
delegateTest4 += DelegateTest2_Mothod;
///减掉一个
delegateTest4 -= DelegateTest2_Mothod;
///减掉一个匿名委托，实际是不起作用的，因为匿名没有“固定”指向名称，所以不能减掉，下面同样会执行
delegateTest4 -= (string msg, string msg2) => { Console.WriteLine("执行委托"); return msg.Length + msg2.Length; };
delegateTest4.Invoke("dd", "eee");
}
int DelegateTest2_Mothod(string msg, string msg2)
{
Console.WriteLine("执行委托");
return msg.Length + msg2.Length;
}
}
执行结果是：
delegateTest1 直接用（delegateTest1("cc", "dd");），Invoke调用，delegateTest1.Invoke("aa", "bb");两次结果完全相同
delegateTest3 begininvoke 是在前面的，结果跑到最后面。异步的原因。
delegateTest4 加了4次委托，减掉2次，但是执行3次，说明了有一次没有减掉。就是匿名没有减掉。
记住委托的作用就是，定义一个方法（函数）的指针。
在编程中，委托是一个非常有用的功能，因为任何异步调用的基础也是委托
.net 框架为我们定义好了两个委托，一个有返回值，一个无返回值，这样我们就免于需要创建委托的重复劳动：
无返回
Action
Action<string>
0-16个参数，无返回值
在系统当中大量使用
有返回
func<int>
fun<string,int> 第一个是参数，最后是返回值
1-17，前面是参数，最后一个是返回值
在系统当中大量使用
1、异步必须要用委托
2、方法像类型一样传递，可以分离业务逻辑
事件的基础就是委托：
事件在系统中使用的非常之多。
定义一个事件：
/// <summary>
/// 定义一个事件
/// </summary>
public event Action<string> SendEvent;
事件的使用：
static void Main(string[] args)
{
///传引用类型的字符串
Message.Send("晚上好！端午节快乐！");
///传值类型的，int 68
Message.Send(68);
///传一个方法
Message.Send(SendMessage);
DelegateExample delegateExample = new DelegateExample();
delegateExample.Show();
///实例化事件类
MyEvent myevent = new MyEvent();
///订阅事件
myevent.SendEvent += Myevent_SendEvent;
///执行工作
myevent.Send(string.Format("开始：{0}", DateTime.Now));
Console.ReadKey();
}
/// <summary>
/// 订阅的处理方法（确定委托需要指针，指向的方法）
/// </summary>
/// <param name="obj"></param>
private static void Myevent_SendEvent(string obj)
{
Console.WriteLine("返回：{0}", obj);
}
事件演示代码：
public class MyEvent
{
/// <summary>
/// 方法的定义
/// </summary>
/// <param name="msg"></param>
public void MethodDemo(string msg)
{ }
/// <summary>
/// 委托的定义，委托在方法修饰符后面加 delegate
/// 委托没有实体{}
/// </summary>
/// <param name="msg"></param>
public delegate void delegateDemo(string msg);
/// <summary>
/// 事件的定义，事件在委托修饰符后面加 event
/// </summary>
public event delegateDemo eventDemo;
/// <summary>
///
/// 记住，事件必须以一个委托为基础
/// 定义一个事件，本例中以系统自带的 Action 为基础
///
/// </summary>
public event Action<string> SendEvent;
public void Send(string msg)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(15));
///在
if (SendEvent != null)
{
SendEvent(string.Format("Task.Factory.StartNew:{0},{1}", DateTime.Now, msg));
}
});
}
}
运行结果：
委托是一种类型、是一个函数指针、事件就是委托的一个实例
委托加上一个 EVENT 关键字后就变成了事件
事件不能直接赋值。也不能被调用。只能通过+=，-= 来操作委托
委托就是 观察者模式 的实现方法
委托是业务之间逻辑剥离的解决方案。
时间： 2024-10-05 04:44:57