C#泛型委托

在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);//传参int

          Func<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--"我是带参的" 类型的参数，并返回一个 string
            Console.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);//委托声明 AnimalPlay
        static 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]上定积分 $\int_{a}^{b}$ f x ( ) 等于函数图像与x轴所围成的曲边梯形的面积。

怎样求曲边梯形的面积呢？我们把曲边梯形分成无数块细小的矩形，这些小矩形面积之和即可以看做曲边梯形面积的近似值。显然小矩形分得越细，面积就越精确。假如我们把它分成1000份，则每个小矩形的宽度为: $\Delta = \frac{b-a}{1000}$

第i个小矩形的宽为Δ，高为f(a+iΔ)，所以其面积为:Si=Δ*f(a+iΔ)

故函数f(x)在区间[a,b]上的定积分（曲边梯形的面积）为: $\int_{a}^{b}$ f x ( )= $\sum_{i=1}^{1000}$ Si= $\sum_{i=1}^{1000}$ Δ*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);
}