C#入门一一委托(delegate)

一、委托的使用

       委托可以理解为函数的一个包装，它使得C#中的函数可以作为参数来被传递，这在作用上相当于C++中的函数指针。

我们先来看一个完整的委托示例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Example_delegate1
{
    class Program
    {
        //1.声明委托类型
        delegate double ProcessDelegate( double param1, double param2 );
        //2.定义委托所包装的方法
        static double Multiply( double param1, double param2 )
        {
            return param1 * param2;
        }
        static double Divide( double param1, double param2 )
        {
            return param1 / param2;
        }

        static void Main( string[ ] args )
        {
            //3.声明委托变量
            ProcessDelegate process;
            Console.WriteLine( "Enter 2 numbers separated with a comma:" );
            string input = Console.ReadLine( );
            int commaPos = input.IndexOf( ',' );
            double param1 = Convert.ToDouble( input.Substring( 0, commaPos ) );
            double param2 = Convert.ToDouble( input.Substring( commaPos + 1, input.Length - commaPos - 1 ) );
            Console.WriteLine( "Enter M to multiply or D to divide:" );
            input = Console.ReadLine( );
            //4.实例化委托
            if( input == "M" )
                process = new ProcessDelegate( Multiply );
            else
                process = new ProcessDelegate( Divide );
            Console.WriteLine( "Result: {0}", ExecuteFunction( process, param1, param2 )/*process( param1, param2 )*/ );
            Console.ReadKey( );
        }

        //5.作为参数传递给方法
        static double ExecuteFunction( ProcessDelegate process, double p1, double p2 )
        {
            return process( p1, p2 );
        }
    }
}

运行结果：

下面我们分解委托使用的步骤：

1. 声明委托类型（类似方法声明，只不过使用delegate关键字）

       委托的声明非常类似于函数，但不带函数体，且要使用 delegate 关键字。委托的声明指定了一个返回类型和一个参数列表。 

//1.声明委托类型
delegate double ProcessDelegate(double param1, double param2);

在声明了委托后，就可以定义该委托类型包装的方法。该方法与委托有相同返回类型和参数列表的函数引用。

2. 定义委托所包装的方法

//2.定义委托所包装的方法
static double Multiply(double param1, double param2)
{
  return param1 * param2;
}
static double Divide(double param1, double param2)
{
  return param1 / param2;
}

3. 声明委托变量

//3.声明委托变量
ProcessDelegate process;

4. 实例化委托

       类的实例化使用new关键字来实现，而委托也属于类类型，所以委托的实例化也使用new关键字。

注意：委托的实例化是用一个方法名（不能带左右括号）作为参数，并且该方法的定义必须符合委托的定义。

//4.实例化委托
if (input == "M")
    process = new ProcessDelegate(Multiply); //process = Multiply;
  else
    process = new ProcessDelegate(Divide); //process = Divide;

5. 在方法中调用委托

//方法的参数是委托类型
static double ExecuteFunction( ProcessDelegate process, double p1, double p2 )
{
    //在方法中调用委托
    return process( p1, p2 );
}

6. 将委托作为函数参数传递给方法

//5.作为参数传递给方法
Console.WriteLine( "Result: {0}", ExecuteFunction( process, param1, param2 )/*process( param1, param2 )*/ );

之后，就可以使用委托变量调用这个函数，就像该变量是一个函数一样。 （类似于C/C++中的函数指针）

二、为什么要引入委托

委托的作用：委托使得一个方法可以作为另一个方法的参数进行传递。

原因：委托可以提高方法扩展性，当我们还需要添加其他操作方法的时候，比如打印两个数之和的操作时，只需定义一个额外的方法Add()，并将该方法传递到对应委托即可

如下所示：

static double Add(double param1, double param2)
{
  return param1 + param2;
}

//4.实例化委托
if (input == "M")
  process = new ProcessDelegate(Multiply); //process = Multiply;
else if(input == "A")
  process = new ProcessDelegate(Add); //process = Add;
else
  process = new ProcessDelegate(Divide); //process = Divide;

三、委托的本质

       上述我们都是通过隐式方式调用委托，其实其背后是通过调用Invoke方法来实现的，只不过这一步由编译器帮我们完成了。委托其实是类类型的。