C# 委托 C函数指针

 《C#高级编程》里说“.Net已委托的形式实现了函数指针的概念”，这里简单比较一下两者的区别：

1 首先看看C下的“函数指针”如何声明和定义一个函数变量：

typedef int (*FUNC)(int x, int y);         //声明

FUNC     func;                                          //定义一个“函数变量”

当已经有这样一个实现的函数时：

int SomeFn(int m, int n)

{

    //函数实现

}

就可以将这个SomeFn 函数名赋值给 func变量：

              func = SomeFn;

使用它：

       func（100, 200）

2 再来看看C#里委托如何实现上面所说，仍然使用上述的SomeFn函数实现：

声明一个委托“类”（在C#中没有全局函数概念，只有类）：

              private delegate void FUNC (int x, int y );           // private是public没关系

也的确，当你写完了上句后，在VS2005中，发现Func是和其他的“类”是并列的。

       再来声明一个变量，并new一个：

FUNC func = new FUNC (SomeFn)

注意new后面函数名后跟的参数不是SomeFn的两个参数，而是SomeFn本身函数名，不过，这时的SomeFn实现若放在同一个类中，需添加一个static 关键字。

使用它，同上面的C语言一样：

       func（100, 200）

文章出处：DIY部落(http://www.diybl.com/course/4_webprogram/asp.net/netjs/20090316/161868.html)

 

 

 

C#委托的例子：

以前对dot net 委托的理解 ,没有一个很好的理解,总是不清不混的,今天在<<C#高级编程(第六版)>>,总算有了新的看法,不像我以往想象的那么抽象或难以理解,如果你想知道委托到底是怎么回事的话,就慢慢看下去,真谛再现,哈哈哈...


1.  简单的委托示例

在这个示例中，定义一个类MathsOperations，它有两个静态方法，对double类型的值执行两个操作，然后使用该委托调用这些方法。这个数学类如下所示：

   class MathsOperations
   {
      public static double MultiplyByTwo(double value)
      {
             return value*2;
      }
      public static double Square(double value)
      {
            return value*value;
      }
   }

下面调用这些方法：

using System;
namespace Wrox.ProCSharp.Delegates
{

   delegate double DoubleOp(double x);
   class Program
   {
      static void Main()
      {
          DoubleOp [] operations =
          {
               MathsOperations.MultiplyByTwo,
               MathsOperations.Square
           };

         for (int i=0 ; i<operations.Length ; i++)
         {
            Console.WriteLine("Using operations[{0}]:", i);
           
            ProcessAndDisplayNumber(operations, 2.0);
           
            ProcessAndDisplayNumber(operations, 7.94);

            ProcessAndDisplayNumber(operations, 1.414);

            Console.WriteLine();

         }

      }

      static void ProcessAndDisplayNumber(DoubleOp action, double value)
      {
              double result = action(value);

              Console.WriteLine( "Value is {0}, result of operation is {1}", value, result);
       }

   }

}

在这段代码中，实例化了一个委托数组DoubleOp (记住，一旦定义了委托类，就可以实例化它的实例，就像处理一般的类那样—— 所以把一些委托的实例放在数组中是可以的)。该数组的每个元素都初始化为由MathsOperations类执行的不同操作。然后循环这个数组，把每个操作应用到3个不同的值上。这说明了使用委托的一种方式—— 把方法组合到一个数组中，这样就可以在循环中调用不同的方法了。

这段代码的关键一行是把委托传递给ProcessAndDisplayNumber()方法，例如：

            ProcessAndDisplayNumber(operations, 2.0);

其中传递了委托名，但不带任何参数，假定operations是一个委托，其语法是：

●       operations表示“这个委托”。换言之，就是委托代表的方法。

●       operations(2.0)表示“调用这个方法，参数放在括号中”。

ProcessAndDisplayNumber()方法定义为把一个委托作为其第一个参数：

      static void ProcessAndDisplayNumber(DoubleOp action, double value)

在这个方法中，调用：

         double result = action(value);

这实际上是调用action委托实例封装的方法，其返回结果存储在result中。

运行这个示例，得到如下所示的结果：

SimpleDelegate

Using operations[0]:

Value is 2, result of operation is 4

Value is 7.94, result of operation is 15.88

Value is 1.414, result of operation is 2.828

Using operations[1]:

Value is 2, result of operation is 4

Value is 7.94, result of operation is 63.0436

Value is 1.414, result of operation is 1.999396