我要评论在 .net core 中，委托（delegate）是一种类型安全的函数指针，它允许你将方法作为参数传递给其他方法，或者将方法存储在变量中以便稍后调用。委托在事件处理、回调机制以及异步编程中非常有用。理解委托的运行原理对于掌握 .net core 的高级编程技巧至关重要。
1. 委托的基本概念
委托是一种引用类型，它引用一个或多个方法。委托定义了方法的签名（参数类型和返回类型），因此只有具有相同签名的方法才能被委托引用。
1.1 定义委托
你可以通过 delegate 关键字来定义一个委托类型。例如：
// 定义一个委托类型 public delegate void greetdelegate(string name);
这个委托类型 greetdelegate 可以引用任何具有 void 返回类型和 string 参数的方法。
1.2 实例化委托
一旦定义了委托类型，你可以创建该委托的实例，并将方法赋值给它。例如：
// 与委托签名匹配的方法
public void greet(string name)
{
console.writeline($"hello, {name}!");
}
// 创建委托实例并绑定方法
greetdelegate del = new greetdelegate(greet);在这个例子中，del 是一个委托实例，它引用了 greet 方法。
1.3 调用委托
你可以像调用方法一样调用委托：
// 调用委托
del("world");这会调用 del 方法，并输出 "hello, world!"。
2.委托的类型
1. 单播委托（singlecast delegate）
单播委托是指一个委托实例只能引用一个方法。这是最基本的委托类型。
public delegate void greetdelegate(string message);
public void showmessage(string message)
{
console.writeline(message);
}
greetdelegate del = new greetdelegate(showmessage);
del("hello, world!"); // 输出：hello, world!2. 多播委托（multicast delegate）
多播委托是指一个委托实例可以引用多个方法。通过 += 运算符可以将多个方法添加到委托实例中，并通过 -= 运算符移除方法。
public void showmessage1(string message)
{
console.writeline($"message 1: {message}");
}
public void showmessage2(string message)
{
console.writeline($"message 2: {message}");
}
public void showmessage3(string message)
{
console.writeline($"message 3: {message}");
}
greetmulticastdelegate del = new greetmulticastdelegate(showmessage1);
del += showmessage2;
del += showmessage3;
del -= showmessage2;
del("hello, world!");在这个例子中，del 委托实例引用了多个方法：将showmessage1,showmessage2 和 showmessage3添加到了多播委托实例中，然后并通过 -= 运算符移除showmessage2。然后调用 del("hello, world!") 时，三个方法都会被调用，输出如下：
message 1: hello, world! //showmessage2方法已移除 message 3: hello, world!
3. 泛型委托（generic delegate）
泛型委托是 c# 中的一种特殊委托类型，它允许你定义可以处理多种数据类型的委托。通过使用泛型，你可以编写更通用、更灵活的代码，而不需要为每种数据类型单独定义委托。
以下是几个泛型委托的示例，展示了如何使用泛型委托处理不同类型的数据。
3.1 简单的泛型委托
public delegate t mygenericdelegate<t>(t arg);
public int square(int x)
{
return x * x;
}
public string reverse(string s)
{
return new string(s.reverse().toarray());
}
mygenericdelegate<int> intdelegate = new mygenericdelegate<int>(square);
console.writeline(intdelegate(5)); // 输出：25
mygenericdelegate<string> stringdelegate = new mygenericdelegate<string>(reverse);
console.writeline(stringdelegate("hello")); // 输出：olleh- • 说明：
- •
mygenericdelegate实例化了一个处理int类型数据的委托。 - •
mygenericdelegate实例化了一个处理string类型数据的委托。
- •
3.2 多参数泛型委托
public delegate tresult mygenericdelegate<t1, t2, tresult>(t1 arg1, t2 arg2);
public int add(int a, int b)
{
return a + b;
}
public string concat(string s1, string s2)
{
return s1 + s2;
}
mygenericdelegate<int, int, int> intdelegate = new mygenericdelegate<int, int, int>(add);
console.writeline(intdelegate(3, 5)); // 输出：8
mygenericdelegate<string, string, string> stringdelegate = new mygenericdelegate<string, string, string>(concat);
console.writeline(stringdelegate("hello, ", "world!")); // 输出：hello, world!- • 说明：
- •
mygenericdelegate实例化了一个处理两个int类型参数并返回int类型结果的委托。 - •
mygenericdelegate实例化了一个处理两个string类型参数并返回string类型结果的委托。
- •
4. 内置委托类型
c# 提供了一些内置的泛型委托类型，可以直接使用，而无需自定义委托。
4.1 action 委托
action 委托用于引用没有返回值的方法。它可以有 0 到 16 个参数。
action<string> action = (message) => console.writeline(message);
action("hello, world!"); // 输出：hello, world!4.2 func 委托
func 委托用于引用有返回值的方法。它可以有 0 到 16 个参数，最后一个泛型参数是返回值类型。
func<int, int, int> add = (a, b) => a + b; console.writeline(add(3, 5)); // 输出：8
4.3 predicate 委托
predicate 委托用于引用返回布尔值的方法，通常用于条件判断。
predicate<int> iseven = (num) => num % 2 == 0; console.writeline(iseven(4)); // 输出：true
5. 匿名方法委托
匿名方法允许你直接定义委托的实现，而无需显式声明一个方法。
mydelegate del = delegate(string message)
{
console.writeline(message);
};
del("hello, world!"); // 输出：hello, world!6. lambda 表达式委托
lambda 表达式是一种更简洁的匿名方法写法，通常用于定义委托。
action<string> action = (message) => console.writeline(message);
action("hello, world!"); // 输出：hello, world!
func<int, int, int> add = (a, b) => a + b;
console.writeline(add(3, 5)); // 输出：87. 事件委托
事件是一种特殊的委托，通常用于实现观察者模式。事件委托通常与 eventhandler 或 eventhandler 一起使用。
public class button
{
public event eventhandler click;
public void onclick()
{
click?.invoke(this, eventargs.empty);
}
}
public class program
{
public static void main()
{
button button = new button();
button.click += (sender, e) => console.writeline("button clicked!");
button.onclick(); // 输出：button clicked!
}
}8. 异步委托
异步委托允许你异步调用方法，通常与 begininvoke 和 endinvoke 一起使用。
public delegate int myasyncdelegate(int x, int y);
public int add(int a, int b)
{
return a + b;
}
myasyncdelegate del = new myasyncdelegate(add);
iasyncresult result = del.begininvoke(3, 5, null, null);
int sum = del.endinvoke(result);
console.writeline(sum); // 输出：89. 动态委托
动态委托允许你在运行时动态创建和调用委托。
public int multiply(int a, int b)
{
return a * b;
}
var method = typeof(program).getmethod("multiply");
var del = delegate.createdelegate(typeof(func<int, int, int>), null, method);
int result = (del as func<int, int, int>)(3, 5);
console.writeline(result); // 输出：153. 委托的运行原理
委托的运行原理涉及到 .net core 的运行时机制和内部实现。以下是委托运行原理的关键点：
3.1 委托的内部结构
在 .net core 中，委托是一个类，它继承自 system.multicastdelegate 类。system.multicastdelegate 类又继承自 system.delegate 类。委托类包含以下关键成员：
- •
_target：指向调用方法的对象实例（如果是静态方法，则为null）。 - •
_methodptr：指向方法的函数指针。 - •
_invocationlist：用于存储多播委托中的多个方法。
3.2 委托的调用
当你调用委托时，.net core 运行时会执行以下步骤：
- 1. 检查委托实例是否为****
**null**：如果委托实例为null，则会抛出nullreferenceexception。 - 2. 调用委托的****
**invoke******方法：委托实例的invoke方法会被调用，该方法会根据_target和_methodptr调用实际的方法。 - 3. 处理多播委托：如果委托是多播委托（即
_invocationlist不为null），则invoke方法会遍历_invocationlist，依次调用每个方法。
3.3 委托的优化
.net core 对委托的调用进行了优化，以提高性能。例如，对于单播委托（即只引用一个方法的委托），.net core 会直接调用方法，而不需要通过 invoke 方法。
4. 委托的应用场景
委托在 .net core 中有多种应用场景，以下是一些常见的场景：
4.1 事件处理
委托在事件处理中非常常见。事件是一种特殊的委托，它允许对象在发生某些事情时通知其他对象。例如：
c#public class button
{
public event action click;
public void onclick()
{
click?.invoke();
}
}
public class program
{
public static void main()
{
button button = new button();
button.click += () => console.writeline("button clicked!");
button.onclick();
}
}在这个例子中，button 类定义了一个 click 事件，当 onclick 方法被调用时，事件处理程序会被触发。
4.2 回调机制
委托可以用于实现回调机制，允许一个方法在完成时通知另一个方法。例如：
public void dowork(action callback)
{
// 执行一些工作
console.writeline("work is done.");
// 调用回调方法
callback?.invoke();
}
public void main()
{
dowork(() => console.writeline("callback called."));
}在这个例子中，dowork 方法在完成工作后调用传入的回调方法。
4.3 异步编程
委托在异步编程中也非常有用。例如，task 类的 continuewith 方法允许你在任务完成时执行一个委托：
task.run(() => console.writeline("task is running..."))
.continuewith(task => console.writeline("task is completed."));5. 总结
委托是 .net core 中一个非常强大的特性，它允许你将方法作为参数传递、存储和调用。理解委托的运行原理有助于你更好地利用这一特性，特别是在事件处理、回调机制和异步编程中。通过掌握委托，你可以编写更加灵活和可扩展的代码。
到此这篇关于.net core 委托原理解析的文章就介绍到这了,更多相关.net core 委托原理内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论