C#中的delegate关键字用于定义方法签名契约，可引用符合签名的方法，支持回调、事件处理及多播机制，常通过Action和Func泛型委托简化使用，并配合event实现安全的发布-订阅模式。
C#中的
delegate
在C#中，定义和使用委托主要包括以下几个步骤：
1. 定义委托类型： 使用
delegate
// 定义一个没有参数，没有返回值的委托 public delegate void SimpleDelegate(); // 定义一个接受一个字符串参数，返回值为int的委托 public delegate int ProcessMessageDelegate(string message); // 定义一个接受两个int参数，返回值为bool的委托 public delegate bool ComparatorDelegate(int a, int b);
2. 创建委托实例并关联方法： 一旦定义了委托类型，你就可以创建它的实例。创建实例时，你需要将一个符合委托签名的方法赋值给它。这个方法可以是静态方法，也可以是实例方法。
// 假设我们有一些方法符合上述委托的签名
public class MyCalculator
{
public static void SayHello()
{
Console.WriteLine("Hello from SimpleDelegate!");
}
public int CalculateLength(string text)
{
Console.WriteLine($"Processing message: {text}");
return text.Length;
}
public static bool IsGreaterThan(int x, int y)
{
return x > y;
}
}
// 在某个地方创建委托实例
public static void Main(string[] args)
{
// 关联静态方法
SimpleDelegate del1 = MyCalculator.SayHello;
// 也可以使用更简洁的语法
// SimpleDelegate del1 = new SimpleDelegate(MyCalculator.SayHello);
MyCalculator calculator = new MyCalculator();
// 关联实例方法
ProcessMessageDelegate del2 = calculator.CalculateLength;
// 关联另一个静态方法
ComparatorDelegate del3 = MyCalculator.IsGreaterThan;
// 甚至可以使用匿名方法或Lambda表达式来创建委托实例（后续会详细说明）
SimpleDelegate del4 = () => Console.WriteLine("Hello from Lambda!");
}3. 调用委托： 调用委托实例就像调用普通方法一样。当委托被调用时，它会执行它所引用的方法。
public static void Main(string[] args)
{
SimpleDelegate del1 = MyCalculator.SayHello;
del1(); // 输出: Hello from SimpleDelegate!
MyCalculator calculator = new MyCalculator();
ProcessMessageDelegate del2 = calculator.CalculateLength;
int length = del2("C# Delegates"); // 输出: Processing message: C# Delegates
Console.WriteLine($"Length: {length}"); // 输出: Length: 12
ComparatorDelegate del3 = MyCalculator.IsGreaterThan;
bool result = del3(10, 5);
Console.WriteLine($"Is 10 > 5? {result}"); // 输出: Is 10 > 5? True
}4. 多播委托（Multicast Delegates）： 委托是多播的，这意味着一个委托实例可以引用多个方法。你可以使用
+=
-=
public class EventPublisher
{
public delegate void NotificationDelegate(string message);
public NotificationDelegate OnNotify;
public void SendNotification(string msg)
{
Console.WriteLine($"Publisher sending: {msg}");
// 重要的安全调用：在调用前检查委托是否为null
OnNotify?.Invoke(msg);
}
}
public class Subscriber
{
private string _name;
public Subscriber(string name) => _name = name;
public void ReceiveNotification(string message)
{
Console.WriteLine($"{_name} received: {message}");
}
}
public static void Main(string[] args)
{
EventPublisher publisher = new EventPublisher();
Subscriber sub1 = new Subscriber("Alice");
Subscriber sub2 = new Subscriber("Bob");
publisher.OnNotify += sub1.ReceiveNotification; // 添加Alice的方法
publisher.OnNotify += sub2.ReceiveNotification; // 添加Bob的方法
publisher.OnNotify += (msg) => Console.WriteLine($"Lambda subscriber received: {msg}"); // 添加一个Lambda表达式
publisher.SendNotification("Hello World!");
// 输出:
// Publisher sending: Hello World!
// Alice received: Hello World!
// Bob received: Hello World!
// Lambda subscriber received: Hello World!
Console.WriteLine("\n--- Removing Bob ---");
publisher.OnNotify -= sub2.ReceiveNotification; // 移除Bob的方法
publisher.SendNotification("Goodbye Bob!");
// 输出:
// Publisher sending: Goodbye Bob!
// Alice received: Goodbye Bob!
// Lambda subscriber received: Goodbye Bob!
}委托是事件的基础，可以说，事件（
event
event
add
remove
+=
-=
委托（Delegate）的常见使用场景：
ComparatorDelegate
// 示例：一个接受比较器委托的排序方法
public static void Sort<T>(List<T> list, Func<T, T, bool> compare)
{
// 内部使用 compare 委托进行元素比较
// ...
}event
BeginInvoke
EndInvoke
async/await
Func<T, TResult>
Action<T>
Where
Func<TSource, bool>
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0); // n => n % 2 == 0 就是一个 Func<int, bool> 委托事件（Event）的常见使用场景：
事件主要用于发布-订阅模式，当某个对象（发布者）的状态发生变化或执行了某个动作时，它需要通知其他感兴趣的对象（订阅者），而发布者不需要知道订阅者的具体类型。
简单来说，如果你只是需要一个方法引用，并且可能需要多播，那么直接使用委托即可。但如果你要实现一个标准的发布-订阅模式，并且希望限制外部对委托的直接操作，那么就应该使用
event
event
匿名方法和Lambda表达式是C#中用于简化委托使用的语法糖。它们允许你在需要委托实例的地方直接定义一个方法体，而无需单独声明一个命名方法。这极大地减少了代码的冗余，并使代码更加紧凑和可读。
1. 匿名方法（Anonymous Methods - C# 2.0 引入）： 匿名方法允许你内联定义一个方法，并将其赋值给委托。它的语法是
delegate (parameters) { method body }// 定义一个委托类型
public delegate void MessageProcessor(string message);
public static void Main(string[] args)
{
// 使用命名方法
MessageProcessor processor1 = DisplayMessage;
processor1("Hello from named method!");
// 使用匿名方法
MessageProcessor processor2 = delegate (string msg)
{
Console.WriteLine($"Anonymous method received: {msg.ToUpper()}");
};
processor2("hello from anonymous method!");
// 匿名方法也可以捕获外部变量（闭包）
int counter = 0;
MessageProcessor processor3 = delegate (string msg)
{
counter++; // 捕获并修改外部变量
Console.WriteLine($"[{counter}] Anonymous method with closure: {msg}");
};
processor3("First call"); // 输出: [1] Anonymous method with closure: First call
processor3("Second call"); // 输出: [2] Anonymous method with closure: Second call
}
public static void DisplayMessage(string msg)
{
Console.WriteLine($"Named method received: {msg}");
}匿名方法解决了为短小、一次性使用的回调方法命名的问题，避免了代码中散落着大量只用一次的私有方法。
2. Lambda表达式（Lambda Expressions - C# 3.0 引入）： Lambda表达式是匿名方法的更简洁、更强大的进化。它们在功能上与匿名方法非常相似，但语法更紧凑，并且在LINQ中扮演了核心角色。Lambda表达式的通用形式是
(parameters) => expression or statement block
表达式Lambda： 如果方法体只有一条表达式，可以省略大括号和
return
// Func<T, TResult> 是 .NET 内置的泛型委托，表示一个接受 T 类型参数，返回 TResult 类型值的方法
Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // 输出: 25
Func<string, bool> startsWithA = s => s.StartsWith("A");
Console.WriteLine(startsWithA("Apple")); // 输出: True语句块Lambda： 如果方法体包含多条语句，需要使用大括号。
// Action<T> 是 .NET 内置的泛型委托，表示一个接受 T 类型参数，没有返回值的方法
Action<string> greet = name =>
{
string greeting = $"Hello, {name}!";
Console.WriteLine(greeting);
};
greet("World"); // 输出: Hello, World!Lambda表达式的优势：
在我刚开始接触C#时，匿名方法让我觉得代码一下子变得灵活了许多，但当Lambda表达式出现时，那简直是效率和表达力的飞跃。尤其是配合LINQ使用时，那种行云流水的代码体验，是命名方法和传统委托写法难以比拟的。现在，除非是特别复杂且需要重用的逻辑，我几乎都会优先考虑使用Lambda表达式来定义委托。
委托在C#中是如此强大和灵活，但如果不注意，也可能引入一些不易察觉的问题。我在实际开发中，就曾因为一些委托相关的“坑”而花费不少时间排查。
常见的陷阱：
空引用异常（NullReferenceException）： 这是最常见的问题。如果你定义了一个委托字段（尤其是一个事件），但没有任何方法订阅它，当你尝试调用它时，就会抛出
NullReferenceException
public delegate void MyEventDelegate();
public MyEventDelegate OnSomethingHappened; // 此时为 null
public void DoSomething()
{
// 错误的调用方式，如果 OnSomethingHappened 为 null 会报错
// OnSomethingHappened();
// 正确的做法：在调用前检查是否为 null
if (OnSomethingHappened != null)
{
OnSomethingHappened();
}
// C# 6.0 以后更简洁的写法：
OnSomethingHappened?.Invoke();
}多播委托的返回值： 如果一个委托是多播的（即它引用了多个方法），并且它有返回值，那么调用该委托时，你只会得到最后一个被调用方法的返回值。前面的方法的返回值会被忽略。这在设计上需要特别注意，通常多播委托设计为
void
多播委托的异常处理： 当多播委托中的某个方法抛出异常时，整个委托的调用链就会中断，后续的方法将不会被执行。如果你需要确保所有订阅者都被通知到，即使其中一个失败，你需要手动遍历
GetInvocationList()
public delegate void FaultyDelegate();
public event FaultyDelegate OnFaultyEvent;
public void RaiseFaultyEvent()
{
// 假设 OnFaultyEvent 有多个订阅者，其中一个会抛异常
// OnFaultyEvent?.Invoke(); // 如果第一个抛异常，后续的不会执行
// 更健壮的异常处理方式
Delegate[] invocationList = OnFaultyEvent?.GetInvocationList();
if (invocationList != null)
{
foreach (FaultyDelegate handler in invocationList)
{
try
{
handler();
}
catch (Exception ex)
{
Console.WriteLine($"Error in handler: {ex.Message}");
// 可以选择记录日志或进行其他错误处理，但继续执行其他handler
}
}
}
}内存泄漏： 如果你将一个实例方法添加到静态委托或生命周期更长的委托中，并且忘记在实例不再需要时取消订阅（
-=
最佳实践：
优先使用 event
event
使用 ?.Invoke()
?.Invoke()
null
NullReferenceException
及时取消订阅： 对于事件或委托，当订阅者对象不再需要接收通知时（例如，UI控件被关闭，或一个临时服务完成其工作），务必使用
-=
// 订阅 somePublisher.OnDataReceived += myObject.HandleData; // ... // 在 myObject 不再需要或被销毁时取消订阅 somePublisher.OnDataReceived -= myObject.HandleData;
利用内置泛型委托 Action
Func
Action
Func
Action
Action<T1, T2, ...>
Func
Func<T1, T2, ..., TResult>
TResult
// 使用 Action 替代自定义 delegate void MyAction(string msg);
Action<string> logMessage = msg => Console.WriteLine(msg);
logMessage("Using Action!");// 使用 Func 替代自定义 delegate int MyFunc(int a, int b); Func<int, int, int> add = (
以上就是C#的delegate关键字如何定义委托？怎么使用？的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
497
收藏
