在C#中,delegate
关键字用于声明委托(delegates),委托是一种类型安全的函数指针,允许你传递方法作为参数或从方法返回方法。有时我们需要将一个函数作为另一个函数的参数,这时就要用到委托(Delegate)机 制。
delegate void GDelegate<T>(T t);
定义了一个名为 GDelegate
的泛型委托。这个委托接受一个类型为 T
的参数 t
,并且不返回任何值(void
)。T
是一个类型参数,意味着这个委托可以用于任何类型的方法,只要那个方法有一个参数并且没有返回值。
在C#中,Action 是一个内置的委托(delegate)类型,用于封装没有返回值(即返回类型为 void)的方法。Action 委托有多个重载版本,可以接受不同数量的参数,每个参数可以有不同的类型。
Action 委托的基本定义如下:
public delegate void Action(); // 没有参数
public delegate void Action<T>(T obj); // 一个参数
public delegate void Action<T1, T2>(T1 arg1, T2 arg2); // 两个参数
// ... 以此类推,直到 Action<T1, T2, ..., T16>
在C#中,Func<TResult>
是一个泛型委托,用于封装具有返回值的方法。与 Action
委托不同,Func
委托总是有一个返回值,并且可以接受任意数量的输入参数。在你给出的例子中,Func<String, String>
是一个特定的 Func
委托类型,它接受一个 string
类型的参数并返回一个 string
类型的值。
Func<String,String>func=new Func<String,String>(Method3);
func("我是带返回值的Func委托");
Gdelegate类:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace 泛型委托
{delegate void GDelegate<T>(T t);//定义了一个名为 Gdelegate 的泛型委托。这个委托接受一个类型为 T 的参数 t,并且不返回任何值//T 是一个类型参数,意味着这个委托可以用于任何类型的方法,只要那个方法有一个参数并且没有返回值。internal class Gdelegate//internal 是一个访问修饰符,用于指定一个类型或成员仅在其声明它的程序集中可见{static string result;public static void InvokeDelegate() {GDelegate<string> gdelegate1 = new GDelegate<string>(Method1);//把方法以变量的形式传送,并以方法的形式执行gdelegate1("我是泛型委托1");Action<String>action=new Action<String>(Method1);action("我是泛型委托1-action");//官方版本(不带返回值),效果同
//Action<T>和Func<TResult>这两个内置的委托类型,它们分别在System命名空间中定义,用于处理没有返回值(Action)和带有返回值(Func)的方法。GDelegate<int> gdelegate2= new GDelegate<int>(Method2);gdelegate2(99);//传参intFunc<String,String>func=new Func<String,String>(Method3);result =func("我是带返回值的Func委托");//Func<String, String> 是一个特定的 Func 委托类型,它接受一个 string 类型的参数并返回一个 string 类型的值。}public static void Method1(string str) {Console.WriteLine(str);}public static void Method2(int num){Console.WriteLine("我是泛型委托2:"+num);}public static String Method3(string str){Console.WriteLine(result + "AB");return str+"A";}}
}
Program类:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace 泛型委托
{internal class Program{static void Main(string[] args){Gdelegate.InvokeDelegate();//调用静态方法----类名.方法名string str= Gdelegate.Method3("我是带参的");//str接收的是return str+"A"// Func 委托类型,它接受一个 string--"我是带参的" 类型的参数,并返回一个 stringConsole.WriteLine(str);Console.ReadKey();}}}
启动程序:
AB是在执行:Gdelegate.InvokeDelegate();//调用静态方法----类名.方法名
时执行了: Func<String,String>func=new Func<String,String>(Method3);--->Console.WriteLine(result + "AB");//
而result 此时为null.下一句:result =func("我是带返回值的Func委托:");
result接收了:"我是带返回值的Func委托:"+"A"
所以才有了执行:string str= Gdelegate.Method3("我是带参的");
时的:我是带返回值的Func委托:AAB
执行:Console.WriteLine(str);
我是带参的A
--------------------------------------------
下面我们设计一个马戏表演函数 CircusStart(),它的第一个参数是代表动物表演的函 数,传给它什么样的函数,就进行什么动物的表演。
c#控制台程序:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace delegateAnimalPlay
{internal class Program{//定义委托 delegate void AnimalPlay(string name);//委托声明 AnimalPlaystatic void Main(string[] args){AnimalPlay deleDogPlay = new AnimalPlay(DogPlay); //把函数 DogPlay()转换为 AnimalPlay 型委托CircusStart(deleDogPlay, "Good evening");// 把委托 deleDogPlay 传给函数CircusStart()Console.ReadKey();}static void CircusStart(AnimalPlay animalPlay, string hello)//静态方法 CircusStart 的签名,该方法接受一个 AnimalPlay 委托和一个字符串参数 name{Console.WriteLine("女士们,先生们,我们的马戏表演开始了!");animalPlay(hello);}//函数:狗表演 static void DogPlay(string greetings){Console.WriteLine("{0},I am Snoopy!", greetings);//greetings接收hello--"Good evening,I am Snoopy!"Console.WriteLine(@" 狗在表演_");}//函数:猫表演 static void CatPlay(string greetings){Console.WriteLine("{0},I am Kitty!", greetings);Console.WriteLine(@" 猫在表演");}//函数:狮子表演 static void LionPlay(string greetings){Console.WriteLine("{0},I am Simba!", greetings);Console.WriteLine(@"狮子在表演 ");}
}
}
启动程序:
委托实例deleDogPlay实际上相当于函数DogPlay()的别名。 我们也可以传入CatPlay(),看看结果
在我们的程序中,我们总是调用函数 CircusStart()进行表演,定义该函数时,我们不 知道也不关心传递给它的委托到底代表哪个函数,直到调用函数 CircusStart(),并把实际 参数传递给它时,这个函数才具体化。传给它什么样的具体函数,就进行什么样的表演, 传给它 deleDogPlay,马戏团就进行狗的表演;传给它 deleCatPlay,马戏团就进行猫的表 演;传给它 deleLionPlay,马戏团就进行狮子表演。因此以委托为参数的函数具有一定的 通用性。
------------------------------------
下面我们利用委托的通用性设计一个通用的求定积分的函数。
函数f(x)在区间[a,b]上定积分 f x ( ) 等于函数图像与x轴所围成的曲边梯形的面积。
怎样求曲边梯形的面积呢?我们把曲边梯形分成无数块细小的矩形,这些小矩形面积 之和即可以看做曲边梯形面积的近似值。显然小矩形分得越细,面积就越精确。假如我们 把它分成1000份,则每个小矩形的宽度为:
第i个小矩形的宽为Δ,高为f(a+iΔ),所以其面积为:Si=Δ*f(a+iΔ)
故函数f(x)在区间[a,b]上的定积分(曲边梯形的面积)为: f x ( )=Si=Δ*f(a+iΔ)
求定积分,需要知道积分上限a,积分下限b和被积函数f(x),需要把被积函数以参数的形式传递给定积分函数,所以需要利用委托实现。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace delegateIntegral
{internal class Program{ //被积函数的委托 delegate double Integrand(double x);static void Main(string[] args)//进行定积分运算{double result1 = DefiniteIntegrate(1, 5, F1);double result2 = DefiniteIntegrate(0, 1, F2);Integrand f3 = delegate (double x){return 3 * x + 5;};double result3 = DefiniteIntegrate(2, 8, f3);//匿名函数当作函数的参数Console.WriteLine("result3 = {0}", result3);Console.WriteLine("result1 = {0}", result1);Console.WriteLine("result2 = {0}", result2);Console.ReadKey();}//被积函数F1(x)=2x+1 static double F1(double x){return 2 * x + 1;}//被积函数F2(x)=x2 static double F2(double x){return x * x;}//函数:定积分 static double DefiniteIntegrate(double a, double b, Integrand fun){const int sect = 1000;//分割数目 double delta = (b - a) / sect;double area = 0;for (int i = 1; i <= 1000; i++){area += delta * fun(a + i * delta);}return area;}}
}
运行程序:
利用委托可以实现以函数为参数,提高 程序的通用性。实际上委托也是由类实现的,当我们创建一种委托时,.NET会创建一个从System.Delegate派生出来的类,类中有一个调用列表, 列表中包含着指向被委托函数的引用。学过C++的读者会觉得委托与C++的函数指针非常 类似,然而与C++的函数指针相比,委托是一种类型安全的方式,并能实现很多其它功能。
创建委托实例时不仅可以使用已有的函数,而且可以直接使用匿名函数(Anonymous Function)。
static void Main(string[] args)
{
/ / 匿名函数
Integrand f3 = delegate(double x)
{
return 3 * x + 5;
} ;
double result3= DefiniteIntegrate(2, 8, f3);
Console.WriteLine("result3 = {0}", result3);
}
也可以直接把匿名函数当作函数的参数。 double result3 = DefiniteIntegrate(2,8, delegate(double x){ return 3*x+5;});
利用匿名函数可以直接把“代码块”定义成委托,而不需要事先定义函数。在上面的 代码中我们定义了一个Integrand型委托f3,该委托的具体代码在后面的花括号中(注意, 花括号后要添加分号)。匿名函数有很多优点,比较突出的一个是它不光可以使用代码块 内定义的变量,而且可以使用代码块外定义的变量,即可以使用宿主函数的局部变量。比如下面的代码:
static void Main(string[] args)
{
double a = 3;
double b = 5;
Integrand f4 = delegate(double x)
{
return a * x + b;
} ;
double result4 = DefiniteIntegrate(2, 8, f4);
Console.WriteLine("result4 = {0}", result4);
}
在上面的代码中,在匿名函数内部使用了外部定义的变量a、b,我们把这种情况称为 外层变量被匿名函数捕获,它们的生存周期将延长至委托被销毁为止。