C#基础——委托、Action和Func的使用

1、委托

委托（Delegate）是一种类型，可以用来表示对一个或多个方法的引用。委托提供了一种方便的方式来将方法作为参数传递给其他方法，或将方法存储在数据结构中以供以后调用。

不带参数且没返回值的委托

delegate void HDLDelegat(); //声明了一个无参数返回的委托

//定义一个函数作为委托的主体
static void HaiDiLao() {
	Console.WriteLine("海底捞总部");
}

HaiDiLao(); //如果直接调用不是委托
//使用委托
HDLDelegat hdl = new HDLDelegat(HaiDiLao);
hdl(); //这里就相当于调用了 HaiDiLao()}

带参数没有返回值的委托

//定义委托
delegate void KaiFengCai(int money);

//定义位委托的主体
static void KFC(int money) {
  if (money >= 100000) Console.WriteLine("才可以加盟肯德基");
  else Console.WriteLine("资质不够肯德基");
}

//使用委托
KaiFengCai kaifengcai = new KaiFengCai(KFC);
kaifengcai(1000000);

带参数有返回值的委托

//定义委托
delegate string MaiDangLao(int money);

//定义位委托的主体
static string MDL(int money) {
  string str = "";
  if (money >= 100000) str = "才可以加盟麦当劳";
  else str = "资质不够麦当劳";
  return str;
}

//使用委托
MaiDangLao maidnaglao = new MaiDangLao(MDL);
Console.WriteLine(maidnaglao(1000000));

参数是一个委托的委托

//定义一个委托
delegate void MyDelegate();
//定义一个参数是另一个委托的委托
delegate void MyDelegate3(MyDelegate myDelegate);

static void ProgramMothod() {
	Console.WriteLine("这是MyDelegate的委托");
}
//注意这个方法使用的时候需要传入委托对象
static void ProgramMothod3(MyDelegate mdelegate) {
  mdelegate(); //直接调用这个函数，相当于调用了ProgramMothod函数
}

//使用委托
MyDelegate3 m3 = new MyDelegate3(ProgramMothod3);
m3(ProgramMothod);

参数是一个委托和一个数据类型的委托

//定义一个有参数的委托
delegate void MyDelegate2(int a, int b);
//定义一个参数是委托和数据类型的委托
delegate void MyDelegate4(MyDelegate2 myDelegate, int a);

static void ProgramMothod2(int aValue, int bValue) {
  Console.WriteLine("{0}这是MyDelegate2的委托,{1}", aValue, bValue);
}
//定义一个参数是另一个委托和int类型的方法
static void ProgramMothod4(MyDelegate2 mdelegate, int a) {
  mdelegate(a, 90);
}

 MyDelegate4 m4 = new MyDelegate4(ProgramMothod4);
 m4(ProgramMothod2, 90); //参一是ProgramMothod2，参二是a

泛型也能和委托一起使用

//定义一个泛型委托
delegate void MyDelegate5<T>(T a);

static void ProgramMothod5(string a) {
  Console.WriteLine(a);
}

//使用委托
//委托的目的是：让方法通过委托来调用，加了泛型之后就表示委托的方法里面出来的数据类型需要和泛型有关才可以
MyDelegate5<string> m5 = new MyDelegate5<string>(ProgramMothod5);
m5("使用泛型的委托");

返回类型和参数都设置成泛型

//定义一个参数和返回值都是泛型的委托
delegate T MyDelegate6<T, D, W>(T A, D B, W c); 

static string ProgramMothod6(string a, int b, double c) {
  return a + b + c;
}

//使用委托
MyDelegate6<string, int, double> m6 = new MyDelegate6<string, int, double>(ProgramMothod6);
Console.WriteLine(m6("100", 200, 300f));

Action和Func的使用

官方希望开发者自定义delegate，提供了 Action和Func来协助完成委托

其中Action用来描述一个void返回类型的方法，Func描述一个带有返回类型的方法

2、Action的使用

无返回值无参数的委托

 Action action = new Action(ProgramMothod);
 action();

static void ProgramMothod() {
  Console.WriteLine("无返回类型无参数的方法");
}

无返回类型有一个值的委托

 Action<int> acction2 = new Action<int>(ProgramMothod2);
 acction2(100);
 
 static void ProgramMothod2(int a) {
  Console.WriteLine("无返回类型有一个参数的方法：传递了a{0}", a);
}

无返回值类型有一个string参数和一个类参数的委托

 ~~~csharp

Action<string, People> action3 = new Action<string, People>(ProgramMothod3);
People p = new People();
p.Name = “郭贝贝”;
action3(“这个博主叫做：”, p);

static void ProgramMothod3(string str, People p) {
Console.WriteLine(“无返回值类型有一个string参数和一个类参数的方法” + str + p.Name);
}

//声明一个类
class People {
public string Name;
}
~~~

注意：Action不能委托带有返回类型的方法

//Action action4 = new Action(TextModth1); //报错

3、Func的使用

有返回类型无参数的委托

Func<int> func = new Func<int>(TextModth1);
Console.WriteLine(func()); //100

 static int TextModth1() {
   return 100;
 }

有参数有返回类型的委托

//当设置了多个泛型之后，以最后一个作为返回类型（前面的泛型当作参数类型）
Func<int, string, string> func2 = new Func<int, string, string>(TextModth2);
Console.WriteLine(func2(100, "200")); //100200

 static string TextModth2(int a, string b) {
   return a + b;
 }

有参数有返回类型且返回类型是个类的委托

Func<int, People, People> func3 = new Func<int, People, People>(TextModth3);
People people = new People();
people.Age = 100;
Console.WriteLine(func3(18, people).Age); //118

 static People TextModth3(int age, People p1) {
   People people = new People();
   people.Age = age + p1.Age;
   return people;
 }

class People {
  public string Name;
  public int Age;
}