这是本文档旧的修订版！
90-70-1：简介
关键字：delegate(de li gi t)
委托就是将方法(函数)当作变量进行处理！
delegate与类同级(类外创建) 声明委托的格式要与指向函数格式一样
要使用委托时，
1：要像类一样先声明定义一个委托类型、[是否带有参数或返回值]
[delegate声明委托类型(名)]
2：在实例化委托、指向一个函数
[委托类型名 去声明委托对象] 如果没有指像一个函数代表、仅仅只是委托待发布而已
系统预定义委托格式(系统定义好的委托、直接用就行)
Action(A e k xing):表示无返回值的委托类型
Func<T>(fang k):表示有返回值的委托类型、返回T类型[泛型]
系统预定义委托格式好处不用自己定义委托及格式
90-70-2：委托案例1[自定义委托] ``` using System; 定义一个委托类型，它接受两个整数参数并返回一个布尔值结果 public delegate bool CompareDelegate(int a, int b); class Program { static void Main() { 创建一个委托实例，并将其指向IsGreater方法
CompareDelegate compare = IsGreater;
// 调用委托实例，实际上调用的是IsGreater方法
bool result = compare(5, 3);
Console.WriteLine("Is 5 greater than 3? " + result); // 输出：Is 5 greater than 3? True
}
// 定义一个与委托签名匹配的方法
static bool IsGreater(int a, int b)
{
return a > b;
}
} ```
在这个示例中，我们首先定义了一个名为`CompareDelegate`的委托类型，它接受两个整数参数并返回一个布尔值结果。
然后，我们在`Main`方法中创建了一个`CompareDelegate`类型的委托实例`compare`，并将其指向了`IsGreater`方法。
最后，我们通过调用委托实例`compare`来间接调用`IsGreater`方法，并将结果输出到控制台。
# 委托案例2[自定义委托] ``` using System;
定义一个委托类型，它接受一个字符串参数并返回一个布尔值结果 public delegate bool StringFilter(string input); class Program { static void Main() { 实例化一个委托对象，并将其指向IsLongEnough方法
StringFilter filter = IsLongEnough;
// 调用委托实例，实际上调用的是IsLongEnough方法
bool result = filter("Hello, world!");
Console.WriteLine("Is 'Hello, world!' long enough? " + result);
输出：Is 'Hello, world!' long enough? True } 定义一个与委托签名匹配的方法返回值与参数一致
static bool IsLongEnough(string input)
{
return input.Length >= 10;
}
}
```
# 委托案例3[一个类调用另外另一个类的方法]
如果一个主类里面的委托想要、指向另外一个类里面的成员函数、
则需要在主类里面、实例化该类的对象、
再用委托的变量等于该类点方法即可、
``` class Program
{
//自定义委托类型
public delegate int Delegate_fion (int a, int b);
static void Main(string[] args)
{
//创建类的对象
jiahuna jiahuna_duixiang = new jiahuna();
//委托指定
Delegate_fion weituo = jiahuna_duixiang.fangfa1;//注意末尾不要括号();
//使用委托
int NUM = weituo(5, 7);
//使用委托
Console.WriteLine(NUM);
Console.ReadKey(); //等待用户输入任意键
}
}
class jiahuna
{
public int fangfa1( int a , int b)
{
int max = a * b;
return max;
} }
```
# 系统预定义Action委托
Action委托是一种特殊的委托类型，它表示一个没有返回值的方法。下面是一个使用Action委托的示例：
``` using System; class Program {
static void Main()
{
// 创建一个Action委托实例，并将其指向PrintMessage方法
Action<string> print = PrintMessage;
// 调用委托实例，实际上调用的是PrintMessage方法
print("Hello, world!"); // 输出：Hello, world!
}
// 定义一个与Action委托签名匹配的方法
static void PrintMessage(string message)
{
Console.WriteLine(message);
}
} ```
在这个示例中，我们首先定义了一个名为`PrintMessage`的方法，它接受一个字符串参数并打印到控制台。
然后，我们在`Main`方法中创建了一个`Action<string>`类型的委托实例`print`，并将其指向了`PrintMessage`方法。
最后，我们通过调用委托实例`print`来间接调用`PrintMessage`方法，并将结果输出到控制台。 # 系统预定义Func委托1
在C#中，`Func<T1, T2, …, TResult>`委托表示一个接受指定数量的输入参数并返回结果的方法。它的参数类型由泛型参数 `T1, T2, …, TResult` 定义。
具体来说，`Func<T1, T2, …, TResult>` 委托有以下特点：
- `T1, T2, …`: 这些是输入参数的类型，可以是任何有效的 C# 类型，包括值类型、引用类型和自定义类型。 - `TResult`: 这是委托返回的结果类型，也可以是任何有效的 C# 类型。
例如，以下是一个使用 `Func` 委托的示例，它接受两个整数作为输入参数，并返回它们的和：
``` using System;
class Program {
static void Main()
{
// 创建一个Func委托实例，并将其指向Add方法
Func<int, int, int> add = Add;
// 调用委托实例，实际上调用的是Add方法
int result = add(3, 4);
Console.WriteLine("3 + 4 = " + result); // 输出：3 + 4 = 7
}
// 定义一个与Func委托签名匹配的方法
static int Add(int a, int b)
{
return a + b;
}
} ```
在这个示例中，我们创建了一个 `Func<int, int, int>` 类型的委托实例 `add`，并将其指向了 `Add` 方法。然后，我们通过调用委托实例 `add` 来间接调用 `Add` 方法，并将结果输出到控制台。 # 系统预定义Func委托2
``` static void Main(string[] args) {
Func<int,int, int> jshuan = Jshuan; //第一与二个int是输入参数的类型 第三个int是返回值的类型 int he = jshuan(1, 2);//委托指向那个方法、调用委托=调用那个方法 Console.WriteLine(he);// =3
}
static int Jshuan(int a ,int b)// 方法2(用委托调用)
{
int Xmod=a + b;
return Xmod;
}
```
# 匿名方法
了解匿名方法前要了解以下：
委托就是将方法(函数)当作变量进行处理！
在实例化委托使、需要指向一个函数
若使用匿名方法则在创建委托对象时、同步创建该方法体、
``` class Program {
//自定义委托类型
public delegate int Delegate_fion (int a, int b);
static void Main(string[] args)
{
//使用匿名方法创建委托对象[同步创建方法体]
Delegate_fion niming_weituo = delegate (int a, int b)
{
return a * b;
};
//使用委托
int NUM = niming_weituo(5, 7);
//使用匿名方法【匿名委托】
Console.WriteLine(NUM);
Console.ReadKey(); //等待用户输入任意键
}
}
```
张叶安