1.委托（delegate ）
委托是一种类型，它可以存储对一个或多个方法的引用。它类似于C/C++中的函数指针，允许您将方法作为参数传递、存储和调用。
写法：
delegate <return_type> <delegate_name>( );
<return_type>：表示委托所引用方法的返回类型。<delegate_name>：表示委托的名称。<parameters>：表示委托所引用方法的参数列表。
//以下是一个示例，说明如何定义和使用委托：
delegate void MyDelegate(string message);
class Program
{
static void Main()
{
MyDelegate del = new MyDelegate(ShowMessage);
del("Hello, world!");
}
static void ShowMessage(string message)
{
Console.WriteLine(message);
}
}
具体应用示例：
namespace WinFormsTest
{
/// <summary>
/// https://www.bilibili.com/video/BV1E14y1C7sm/?spm_id_from=333.337.search-card.all.click&vd_source=c17a6596481e29f0ffac1a21a026abff
/// 委托有什么用？
/// 1.将方法作为参数进行传递，有利于方法的解耦和隔离
/// 2.声明事件并进行注册
/// 定义委托的格式
/// 1.声明委托类型
/// 2.必须有一个方法包含了要执行的代码，这个方法必须符合委托类型签名
/// 3.创建一个委托实例
/// 4.必须调用invoke委托实例
/// </summary>
delegate void MyDelegate(); //定义一个委托，无参数和返回值
delegate string MyDelegate2(int a, int b);
public partial class delegateAndevent : Form
{
public delegateAndevent()
{
InitializeComponent();
//Type type = typeof(myDelegate);
//if (type.IsClass) MessageBox.Show("这是一个类");
//MyDelegate myDelegate = new MyDelegate(Method1);
下面两种方法都可以到委托中调用新的方法
//MyDelegate myDelegate2 = new MyDelegate(Method2);
//myDelegate += myDelegate2;
myDelegate += Method2; //在委托中添加方法
myDelegate -= Method2; //在委托中去除方法
//myDelegate.Invoke();
string result1 = myCal(5, 5, Add);
string result2 = myCal(5, 5, Multiple);
//MessageBox.Show(result1 + "..........." + result2);
}
void Method1()
{
MessageBox.Show("调用了方法1");
}
void Method2()
{
MessageBox.Show("调用了方法2");
}
String myCal(int a, int b, MyDelegate2 myDelegate)
{
return myDelegate(a, b);
}
//没有定义方法的修饰符时，private为默认，如果与namespace为同一级时则internal为默认
string Add(int a, int b)
{
return (a + b).ToString();
}
string Multiple(int a, int b)
{
return (a * b).ToString();
}
private void btnDelegate_Click(object sender, EventArgs e)
{
//C#中的两种强委托类型 Action<T1> , Func<T1,T2,T3,Tresult>
//Action 不返回值的委托类型 ，最多输入一个参数
Action<string> aa1 = (string a) => { MessageBox.Show(a + "强委托类型 Action<T1>，第一次"); }; //使用lambda表达式
Action<string> aa2 = a => { MessageBox.Show(a + "强委托类型 Action<T1>,第二次"); }; //使用lambda表达式
aa1 += aa2;
aa1.Invoke("使用了：");
//Func<T1,T2,T3,Tresult>
Func<string, string> func = h => h + "强委托类型 Func<T1,T2,T3,Tresult>,第一次";//使用lambda表达式
Func<string, string, string> func2 = (h, b) => h + "强委托类型 Func<T1,T2,T3,Tresult>" + b;//使用lambda表达式
//func += func2; //会报错，同一种类型的委托才可以
string funcResult1 = func.Invoke("使用了：");
string funcResult2 = func2.Invoke("使用了：", "第二次");
MessageBox.Show(funcResult1);
MessageBox.Show(funcResult2);
}
}
}
2.事件（event）
它用于建立一种通讯机制，使得对象可以通知系统某些事情已经发生，而无需知道具体会有哪些对象对此进行响应。
事件与委托: 事件是基于委托（一种特殊的类型安全的函数指针）的。
发布者与订阅者: 发布者负责声明和触发事件，订阅者负责订阅事件并定义响应逻辑。
事件定义: 使用event关键字和相应的委托类型来定义事件。
public delegate void MyEventHandler();
public event MyEventHandler MyEvent;
事件订阅: 使用+=操作符订阅事件，-=操作取消事件订阅。
publisher.MyEvent += MyMethod;
publisher.MyEvent -= MyMethod;
EventArgs: 标准做法是通过一个继承自EventArgs的类来传递事件数据。
事件访问器: 可以使用add和remove关键字可以自定义事件的订阅和取消订阅逻辑。
private MyEventHandler myEvent;
public event MyEventHandler MyEvent
{
add
{
myEvent += value;
}
remove
{
myEvent -= value;
}
}
匿名方法和Lambda: 可以使用匿名方法或Lambda表达式作为事件处理器。
自动事件: 可以使用event关键字简化事件的定义和实现，这样编译器会自动为你实现事件访问器。
示例代码
下面是一个简单的例子，其中包括一个Clock类（发布者）和一个Display类（订阅者）。
using System;
using System.Threading;
// 定义委托（如果使用非泛型EventHandler，需要定义）
public delegate void TimerEventHandler(object sender, EventArgs e);
public class Clock
{
// 基于委托定义事件
public event TimerEventHandler Timer;
// 触发事件的方法
public void RunClock()
{
while (true)
{
Thread.Sleep(1000);
// 触发事件
Timer?.Invoke(this, EventArgs.Empty);
}
}
}
public class Display
{
// 事件处理方法
public void ShowTime(object sender, EventArgs e)
{
Console.WriteLine($"Current time: {DateTime.Now.ToLongTimeString()}");
}
}
class Program
{
static void Main(string[] args)
{
Clock clock = new Clock();
Display display = new Display();
// 订阅事件
clock.Timer += display.ShowTime;
// 启动时钟
clock.RunClock();
}
}
在这个例子中，Clock类每秒触发一次Timer事件，而Display类订阅这个事件并显示当前时间。
具体应用示例：
namespace WinFormsTest
{
public partial class frmEvent : Form
{
/// <summary>
///事件的作用
///希望一个类的某些成员在发生某些变化时能够被外界观测到
///
/// 什么是事件？
/// 事件是委托的实例，限定了执行时的权限，只能在事件所在类的内部执行
/// 事件虽然是public，但是只能在类的内部被调用，因此需要在类的内部定义事件触发的方法
///
///
/// 定义事件的步骤
/// 1.定义事件的委托类型
/// 2.在类的内部声明事件
/// 3.声明事件
/// </summary>
//定义警报委托
public delegate void AlarmEventHandle();
internal class Alarm
{
public event AlarmEventHandle AlarmRaised; //在类的内部声明了一个事件
public void ShowAlarm()
{
MessageBox.Show("1.警报响起！");
Thread.Sleep(1000);
}
//定义事件触发的方法
public void OnAlarmRaised()
{
//if (AlarmRaised != null)
//{
// //AlarmRaised();
// AlarmRaised.Invoke();
//}
AlarmRaised?.Invoke();//上面if的写法等于这个
}
}
public frmEvent()
{
InitializeComponent();
}
private void btnEvent_Click(object sender, EventArgs e)
{
Alarm alarm = new Alarm(); //事件声明，然后订阅方法
alarm.AlarmRaised += alarm.ShowAlarm;
alarm.AlarmRaised += new Person().processAlarm;
alarm.AlarmRaised += () => { MessageBox.Show("3.马上处理结束...."); Thread.Sleep(1000); };
alarm.AlarmRaised += Method1;
//alarm.AlarmRaised -= Method1; //-=订阅移除
alarm.OnAlarmRaised();//触发事件
}
void Method1()
{
MessageBox.Show("4.处理完成!");
Thread.Sleep(1000);
}
public class Person
{
public void processAlarm()
{
MessageBox.Show("2.正在处理中.....");
Thread.Sleep(1000);
}
}
}
}
3.回调函数（callback）
回调函数用于在某个操作完成后执行特定的行为或通知。回调通常通过委托（Delegate）来实现，委托是C#中用于封装方法的对象。
委托（Delegate）: 回调函数在C#中通常使用委托来表示。委托是一个类型安全的函数指针。
public delegate void MyCallback(string message);
异步回调: 在异步编程模型中，可以使用回调函数来处理异步操作的完成。
事件: 事件其实就是一种特殊类型的回调，它允许多个订阅者监听某个行为。
示例
以下是一个简单的回调函数示例：
using System;
public delegate void MyCallback(string message); // 定义委托
public class Operation
{
public void Execute(MyCallback callback)
{
// 执行某些操作...
// ...
// 操作完成后，调用回调函数
callback("Operation completed!");
}
}
//程序入口
public class Program
{
public static void Main()
{
Operation operation = new Operation();
// 定义回调函数
MyCallback callback = (message) =>
{
Console.WriteLine($"Callback invoked: {message}");
};
// 执行操作并传入回调函数
operation.Execute(callback);
}
}
在这个例子中，Operation 类有一个 Execute 方法，该方法接受一个回调函数（MyCallback 委托的实例）。当 Execute 方法的操作完成后，它会调用这个回调函数。
4.匿名函数和lambda表达式
匿名函数: 匿名函数是没有名称、只有函数体的函数。在C#中，你可以使用delegate关键字来创建匿名函数。
delegate(int x) { return x * x; }
Lambda表达式: 是匿名函数的一种更简洁的表示方式，使用=>符号来分隔参数和函数体。
x => x * x
参数类型推断: Lambda表达式通常可以推断参数类型，因此你不必显式声明它。
(x, y) => x + y
多语句Lambda: 使用花括号{}，你可以在Lambda表达式中编写多条语句。
x => { Console.WriteLine(x); return x * x; }
捕获外部变量: 匿名函数和Lambda表达式可以捕获其作用域内的外部变量。
int y = 10;
Func<int, int> addY = x => x + y;
应用场景: 匿名函数和Lambda表达式常用于事件订阅、LINQ查询、异步编程等。
示例代码
使用匿名函数和Lambda表达式来订阅一个事件。
using System;
public class MyEventPublisher
{
public event Action<string> MyEvent;
public void RaiseEvent(string message)
{
MyEvent?.Invoke(message);
}
}
public class Program
{
public static void Main()
{
MyEventPublisher publisher = new MyEventPublisher();
// 使用匿名函数订阅事件
publisher.MyEvent += delegate(string message)
{
Console.WriteLine($"Received message using anonymous method: {message}");
};
// 使用Lambda表达式订阅事件
publisher.MyEvent += message => Console.WriteLine($"Received message using Lambda: {message}");
// 触发事件
publisher.RaiseEvent("Hello, World!");
}
}
精彩推荐：
【C#进阶一】C#中的数组(Array)、集合(ArrayList，Queue，Stack, HashList)、List＜T＞、字典(Dictionary＜K,T＞)和双向链表LinkedList
【C#进阶八】C#中的序列化与反序列化下（二进制序列化、XML序列化及JSON序列化）
【C#进阶】C#语法中一些常用知识点总结
【WinForm详细教程一】WinForm中的窗体、Label、TextBox及Button控件、RadioButton和CheckBox、ListBox
【WinForm详细教程三】WinForm中的NumericUpDown、PictureBox、RichTextBox及三种Timer控件
希望有所帮助，同时欢迎关注我，后面将更新更多相关内容！