Csharp关键字----delegate(委托)

Delegate类简介
------------------------     
命名空间:System
程序集:mscorlib（在 mscorlib.dll 中）

   委托(Delegate)类是一种数据结构，通过它可引用静态方法或引用类实例及该类的实例方法。
以往的界面编程中我们应该都接触过各种类型的事件驱动（event driven）的处理模式，
在这种模式里，我们定义相应事件触发的函数。
例如：
Button1 的 Click事件，我们可以编写Button1_Click 或 Btn1Clicked等函数来做相应的驱动处理。
而事件与驱动函数的对应关系就是通过委托(Delegate)类来关联的。

其实委托(Delegate)类这种数据结构有些类似于之前C/C++中的函数指针。

Delegate类一个简单应用
------------------------    
1.定义一个Delegate函数数据结构
2.定义Delegate将引用的静态方法或引用类实例及该类的实例方法
3.Delegate数据变量指向实例方法
4.通过Delegate数据变量执行实例方法

A very basic example (TestClass.cs):

  1: using System; 

  2: 

  3: namespace MySample

  4: {

  5:     class TestClass

  6:     {

  7:     //1.定义一个Delegate函数数据结构

  8:         public delegate void GoDelegate(); 

  9: 

 10:         [STAThread]

 11:         static void Main(string[] args)

 12:         {

 13:         //3.Delegate数据变量指向实例方法

 14:             GoDelegate goDelegate = new GoDelegate( MyDelegateFunc); 

 15: 

 16:         //4.通过Delegate数据变量执行实例方法

 17:             goDelegate();

 18:             return;

 19:         }

 20:         //2.定义Delegate将引用的静态方法或引用类实例及该类的实例方法

 21:         public static void MyDelegateFunc()

 22:         {

 23:             Console.WriteLine("delegate function...");

 24:         }        

 25:     }

 26: } 

编译执行结果：

# TestClass.exe
delegate function...

使用Delegate类和Override实现多态的比较
-----------------------------------------------

1.使用Delegate类的时候，下面的例子可以很清楚的说明。
  1.1 首先定义一个动物基类(MyAnimalDelegateClass), 基类中有显示属性的(ShowAnimalType)的public方法。
      并且在ShowAnimalType方法中调用Delegate引用的实例方法

  1.2 定义狮子（LionDelegateClass)和马(HorseDelegateClass)两个子类。Delegate与各自的实例方法绑定
      实现不同的属性显示(ShowAnimalType)方法。

////Delegate example (TestClass.cs):

  1: AnonymousDelegatesusing System; 

  2: 

  3: namespace MySample

  4: {

  5:    class TestClass

  6:    {

  7:       [STAThread]

  8:       static void Main(string[] args)

  9:       {

 10:       //狮子（LionDelegateClass)的属性显示(ShowAnimalType)方法调用

 11:          LionDelegateClass lionDelegate = new LionDelegateClass();

 12:          lionDelegate.ShowAnimalType("MySample"); 

 13: 

 14:       //马（HorseDelegateClass)的属性显示(ShowAnimalType)方法调用

 15:          HorseDelegateClass horseDelegate = new HorseDelegateClass();

 16:          horseDelegate.ShowAnimalType("MySample");

 17:       }

 18:    } 

 19: 

 20:    //动物基类(MyAnimalDelegateClass)

 21:    public class MyAnimalDelegateClass

 22:    {

 23:       //Delegate数据结构定义

 24:       public delegate void DelegateFunction(string strFuncName); 

 25: 

 26:       private DelegateFunction m_delegateFunction = null; 

 27: 

 28:       //Delegate类型的属性

 29:       public DelegateFunction delegateFunction 

 30:       {

 31:          get 

 32:          {

 33:             return m_delegateFunction;

 34:          } 

 35:          set 

 36:          {

 37:             m_delegateFunction = value;

 38:          }

 39:       }

 40:       //属性显示(ShowAnimalType)方法

 41:       public void ShowAnimalType(string strFuncName)

 42:       {

 43:          if (delegateFunction != null)

 44:          {

 45:             object[] args = {strFuncName};

 46:          //调用Delegate引用的实例方法

 47:             delegateFunction.DynamicInvoke(args);

 48:          }

 49:       }

 50:    } 

 51: 

 52:    //狮子（LionDelegateClass)

 53:    public class LionDelegateClass:MyAnimalDelegateClass

 54:    {

 55:       public LionDelegateClass()

 56:       {

 57:          this.delegateFunction = new DelegateFunction(subFunction1);

 58:       } 

 59: 

 60:       //狮子（LionDelegateClass)实例方法的实装

 61:       private void subFunction1(string strFuncName)

 62:       {

 63:          System.Console.WriteLine(

 64:             string.Format("[{0}]This is a lion....", strFuncName));

 65:       }

 66:    } 

 67: 

 68:    //马（HorseDelegateClass)

 69:    public class HorseDelegateClass:MyAnimalDelegateClass

 70:    {

 71:       public HorseDelegateClass()

 72:       {

 73:          this.delegateFunction = new DelegateFunction(subFunction2);

 74:       } 

 75: 

 76:       //马（HorseDelegateClass)实例方法的实装

 77:       private void subFunction2(string strFuncName)

 78:       {

 79:          System.Console.WriteLine(

 80:             string.Format("[{0}]This is a horse....", strFuncName));

 81:       }

 82:    }

 83: } 

编译执行结果：

# TestClass.exe

[MySample]This is a lion....
[MySample]This is a horse....

2.使用Override实装的时候，参考下面的例子。
  1.1 首先定义一个动物基类(AbstractAnimalNoDelegateClass), 基类中有显示属性的(ShowAnimalType)的public方法。
      并且在ShowAnimalType方法中调用抽象方法（NoDelegateFunction）

  1.2 定义狮子（LionNoDelegateClass)和马(HorseNoDelegateClass)两个子类。
      子类中实装抽象方法（NoDelegateFunction）
      实现不同的属性显示(ShowAnimalType)方法。

////Override example (TestClass.cs):

  1: using System; 

  2: 

  3: namespace MySample

  4: {

  5:    class TestClass

  6:    {

  7:       [STAThread]

  8:       static void Main(string[] args)

  9:       {

 10:           //狮子（LionNoDelegateClass )的属性显示(ShowAnimalType)方法调用

 11:           LionNoDelegateClass lionNoDelegate = new LionNoDelegateClass();

 12:        lionNoDelegate.ShowAnimalType("MySample"); 

 13: 

 14:           //马（HorseNoDelegateClass )的属性显示(ShowAnimalType)方法调用

 15:        HorseNoDelegateClass horseNoDelegate = new HorseNoDelegateClass();

 16:        horseNoDelegate.ShowAnimalType("MySample");

 17:       }

 18:    } 

 19: 

 20:    //动物基类(AbstractAnimalNoDelegateClass)

 21:     public abstract class AbstractAnimalNoDelegateClass

 22:     {

 23:         public void ShowAnimalType(string strFuncName)

 24:         {

 25:             //抽象方法（NoDelegateFunction）调用

 26:             NoDelegateFunction(strFuncName);

 27:         }

 28:         //在基类中定义抽象方法（NoDelegateFunction）

 29:         protected abstract void NoDelegateFunction(string strFuncName);

 30:     } 

 31: 

 32:     //狮子（LionNoDelegateClass )

 33:     public class LionNoDelegateClass:AbstractAnimalNoDelegateClass

 34:     {

 35:     // 子类中实装抽象方法（NoDelegateFunction）

 36:         protected override void NoDelegateFunction(string strFuncName)

 37:         {

 38:             System.Console.WriteLine(

 39:                 string.Format("[{0}]This is a lion....", strFuncName));

 40:         }

 41:     }

 42:    //马（HorseNoDelegateClass )

 43:     public class HorseNoDelegateClass:AbstractAnimalNoDelegateClass

 44:     {

 45:     // 子类中实装抽象方法（NoDelegateFunction）

 46:         protected override void NoDelegateFunction(string strFuncName)

 47:         {

 48:             System.Console.WriteLine(

 49:                 string.Format("[{0}]This is a horse....", strFuncName));

 50:         }

 51:     }

 52: } 

 53: 

编译执行结果：

# TestClass.exe

[MySample]This is a lion....
[MySample]This is a horse....

3.比较Delegate和Override实装方式
  可以看出Delegate实装方式中，相当于定义一个函数指针的成员变量。
  通过把实装函数的地址赋给该成员变量，实现同样的方法，处理方式的不同。
  而Override方式中，则是在父类中预先定义好接口，通过实装的不同，
  来实现同样的方法，处理方式的不同。
  Delegate实装方式比较灵活，适合设计不是很完善的场合，便于修改。
  Override方式封装性好，相对比较安全。

MulticastDelegate 类的应用
---------------------------------
在C#中，委托(Delegate)类是多路委托，这就说可以同时指向多个处理函数，
并且可以按照委托的先后顺序，执行相应的函数。
如下例:

  1: using System; 

  2: 

  3: namespace MySample

  4: {

  5:     class TestClass

  6:     {

  7:         [STAThread]

  8:         static void Main(string[] args)

  9:         {

 10:             DogDelegateClass dogDelegate = new DogDelegateClass();

 11:             dogDelegate.ShowAnimalType("MySample"); 

 12: 

 13:     } 

 14: 

 15:     public class MyAnimalDelegateClass

 16:     {

 17:         public delegate void DelegateFunction(string strFuncName); 

 18: 

 19:         private DelegateFunction m_delegateFunction = null; 

 20: 

 21:         public DelegateFunction delegateFunction 

 22:         {

 23:             get 

 24:             {

 25:                 return m_delegateFunction;

 26:             } 

 27:             set 

 28:             {

 29:                 m_delegateFunction = value;

 30:             }

 31:         } 

 32: 

 33:         public void ShowAnimalType(string strFuncName)

 34:         {

 35:             if (delegateFunction != null)

 36:             {

 37:                 object[] args = {strFuncName}; 

 38: 

 39:                 delegateFunction.DynamicInvoke(args);

 40:             }

 41:         }

 42:     } 

 43: 

 44:     public class DogDelegateClass:MyAnimalDelegateClass

 45:     {

 46:         public DogDelegateClass()

 47:         {

 48:       //多路委托函数 设定

 49:             this.delegateFunction =  new DelegateFunction(subFunction31);

 50:             this.delegateFunction += new DelegateFunction(subFunction32);

 51:         }

 52:   //委托函数1

 53:         private void subFunction31(string strFuncName)

 54:         {

 55:             System.Console.WriteLine(

 56:                 string.Format("[{0}]This is a dog....", strFuncName));

 57:         }

 58:   //委托函数2

 59:         private void subFunction32(string strFuncName)

 60:         {

 61:             System.Console.WriteLine(

 62:                 string.Format("[{0}]This is a nice dog....", strFuncName));

 63:         }

 64:     }

 65: } 
编译执行结果： # TestClass.exe [MySample]
This is a dog....[MySample]This is a nice dog.... 
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/xinsir/archive/2006/08/22/1106277.aspx

  1: // Copyright © Microsoft Corporation.  All Rights Reserved.

  2: // This code released under the terms of the 

  3: // Microsoft Public License (MS-PL, http://opensource.org/licenses/ms-pl.html.)

  4: //

  5: //Copyright (C) Microsoft Corporation.  All rights reserved.

  6: 

  7: using System;

  8: using System.Collections.Generic;

  9: using System.Text;

 10: 

 11: namespace AnonymousDelegate_Sample

 12: {

 13: 

 14:     // Define the delegate method.

 15:     delegate decimal CalculateBonus(decimal sales);

 16: 

 17:     // Define an Employee type.

 18:     class Employee

 19:     {

 20:         public string name;

 21:         public decimal sales;

 22:         public decimal bonus;

 23:         public CalculateBonus calculation_algorithm;

 24:     }

 25: 

 26:     class Program

 27:     {

 28: 

 29:         // This class will define two delegates that perform a calculation.

 30:         // The first will be a named method, the second an anonymous delegate.

 31: 

 32:         // This is the named method.

 33:         // It defines one possible implementation of the Bonus Calculation algorithm.

 34: 

 35:         static decimal CalculateStandardBonus(decimal sales)

 36:         {

 37:             return sales / 10;

 38:         }

 39: 

 40:         static void Main(string[] args)

 41:         {

 42: 

 43:             // A value used in the calculation of the bonus.

 44:             // Note: This local variable will become a "captured outer variable".

 45:             decimal multiplier = 2;

 46: 

 47:             // This delegate is defined as a named method.

 48:             CalculateBonus standard_bonus = new CalculateBonus(CalculateStandardBonus);

 49: 

 50:             // This delegate is anonymous - there is no named method.

 51:             // It defines an alternative bonus calculation algorithm.

 52:             CalculateBonus enhanced_bonus = delegate(decimal sales) 

 53:             { return multiplier * sales / 10; };

 54: 

 55:             // Declare some Employee objects.

 56:             Employee[] staff = new Employee[5];

 57: 

 58:             // Populate the array of Employees.

 59:             for (int i = 0; i < 5; i++)

 60:                 staff[i] = new Employee();

 61: 

 62:             // Assign initial values to Employees.

 63:             staff[0].name = "Mr Apple";

 64:             staff[0].sales = 100;

 65:             staff[0].calculation_algorithm = standard_bonus;

 66: 

 67:             staff[1].name = "Ms Banana";

 68:             staff[1].sales = 200;

 69:             staff[1].calculation_algorithm = standard_bonus;

 70: 

 71:             staff[2].name = "Mr Cherry";

 72:             staff[2].sales = 300;

 73:             staff[2].calculation_algorithm = standard_bonus;

 74: 

 75:             staff[3].name = "Mr Date";

 76:             staff[3].sales = 100;

 77:             staff[3].calculation_algorithm = enhanced_bonus;

 78: 

 79:             staff[4].name = "Ms Elderberry";

 80:             staff[4].sales = 250;

 81:             staff[4].calculation_algorithm = enhanced_bonus;

 82: 

 83:             // Calculate bonus for all Employees

 84:             foreach (Employee person in staff)

 85:                 PerformBonusCalculation(person);

 86: 

 87:             // Display the details of all Employees

 88:             foreach (Employee person in staff)

 89:                 DisplayPersonDetails(person);

 90: 

 91: 

 92:         }

 93: 

 94:         public static void PerformBonusCalculation(Employee person)

 95:         {

 96: 

 97:             // This method uses the delegate stored in the person object

 98:             // to perform the calculation.

 99:             // Note: This method knows about the multiplier local variable, even though

100:             // that variable is outside the scope of this method.

101:             // The multipler varaible is a "captured outer variable".

102:             person.bonus = person.calculation_algorithm(person.sales);

103:         }

104: 

105:         public static void DisplayPersonDetails(Employee person)

106:         {

107:             Console.WriteLine(person.name);

108:             Console.WriteLine(person.bonus);

109:             Console.WriteLine("---------------");

110:             Console.ReadLine();

111:         }

112:     }

113: }