借助代码及注释了解下委托：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace DelegateExample
{
// 声明一个委托，它的实例引用一个方法，该方法获取一个Int32参数，返回void
// 委托本质上也是类，所以定义类的地方都可以定义委托。
internal delegate void Feedback(Int32 value);
internal class DelegateDemo
{
private static void Counter(Int32 from, Int32 to, Feedback fb)
{
for (Int32 i = from; i <= to; i++)
{
if (fb != null)
fb.Invoke(i); // fb(i);
}
}
// 静态方法
private static void methodConsole(Int32 value)
{
Console.WriteLine(value);
}
// 实例方法
private void methodFile(Int32 value)
{
StreamWriter sw = new StreamWriter("status.txt", true);
sw.WriteLine("Item = " + value);
sw.Close();
}
private static void StaticDelegate()
{
Console.WriteLine("Static Delegate Demo...");
Counter(1, 2, null);
// 委托是一个类，每个委托都有一个构造器
// 委托对象是方法的一个包装器，使方法通过包装器来间接回调
// 此处，将 DelegateEx.methodConsole 传给 FeedBack 委托类型的构造器，
// 表明 methodConsole 就是要包装的方法。
Counter(1, 2, new Feedback(DelegateDemo.methodConsole));
Console.WriteLine();
}
private static void InstanceDelegate()
{
Console.WriteLine("Instance Delegate Demo...");
// 用委托回调实例方法
DelegateDemo d = new DelegateDemo();
Counter(1, 2, new Feedback(d.methodFile));
Console.WriteLine();
}
private static void ChainDelegate(DelegateDemo d)
{
Console.WriteLine("Chain Delegate Demo...");
Feedback fb1 = new Feedback(methodConsole);
Feedback fb2 = new Feedback(d.methodFile);
Feedback fbChain = null;
fbChain = (Feedback)Feedback.Combine(fbChain, fb1); // fbChain += fb1;
fbChain = (Feedback)Feedback.Combine(fbChain, fb2);
Counter(1, 2, fbChain);
Console.WriteLine();
// fbChain -= new Feedback(methodMessBox);
fbChain = (Feedback)Delegate.Remove(fbChain, new Feedback(methodConsole));
Counter(1, 2, fbChain);
}
public static void Excute()
{
StaticDelegate();
InstanceDelegate();
ChainDelegate(new DelegateDemo());
}
}
}
上例是自定义的委托，也可以利用 System.Delegate 类型创建委托，代码示例如下：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.IO;
namespace DelegateExample
{
/// <summary>
/// 定义两个委托
/// </summary>
internal delegate Object TwoInt32s(Int32 n1, Int32 n2);
internal delegate Object OneString(String s);
class Program
{
/// <summary>
/// 4个回调函数
/// </summary>
private static Object Add(Int32 n1, Int32 n2)
{
return n1 + n2;
}
private static Object Subtract(Int32 n1, Int32 n2)
{
return n1 - n2;
}
private static Object NumChars(String s)
{
return s.Length;
}
private static Object Reverse(String s)
{
Char[] chars = s.ToCharArray();
Array.Reverse(chars);
return new String(chars);
}
/// <summary>
/// 了解参数由来
/// </summary>
/// <param name="args">右键项目属性，选择调试选项卡，在命令行参数中设置</param>
static void Main(string[] args)
{
#region 使用Delegate类的CreateDelegate()创建委托
if (args.Length < 2)
{
String fileName = Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().Location);
String usage = @"Usage:" +
"{0}{1} delType methodName [Arg1] [Arg2]" +
"{0} where delType must be TwoInt32s or OneString" +
"{0} if delType is TwoInt32s, methodName must be Add or Subtract" +
"{0} if deltype is OneString, methodName must be NumChars or Reverse" +
"{0}" +
"{0} Examples:" +
"{0} {1} TwoInt32s Add 123,321" +
"{0} {1} TwoInt32s Subtract 123,321" +
"{0} {1} OneString NumChars "Hello There "" +
"{0} {1} OneString Reverse "Hello There "";
Console.WriteLine(usage, Environment.NewLine, fileName);
Console.Read();
return;
}
// 将delType参数转换为一个委托类型
Type delType = Type.GetType(args[0]);
if (delType == null)
{
Console.WriteLine("Invalid delType argument:" + args[0]);
Console.Read();
return;
}
Delegate d;
try
{
// 将Arg1参数转换成一个静态方法
MethodInfo mi = typeof(Program).GetMethod(args[1], BindingFlags.NonPublic | BindingFlags.Static);
// 创建包含了静态方法的一个委托对象
d = Delegate.CreateDelegate(delType, mi);
}
catch(ArgumentException)
{
Console.WriteLine("Invalid methodName argument:" + args[1]);
Console.Read();
return;
}
// 创建一个数组，其中只包含要通过委托对象传给方法的参数
Object[] callbackArgs = new Object[args.Length - 2];
if (d.GetType() == typeof(TwoInt32s))
{
try
{
for (Int32 i = 2; i < args.Length; i++)
{
callbackArgs[i - 2] = Int32.Parse(args[i]);
}
}
catch(FormatException)
{
Console.WriteLine("Parameters must be integers.");
Console.Read();
return;
}
}
if (d.GetType() == typeof(OneString))
{
Array.Copy(args, 2, callbackArgs, 0, callbackArgs.Length);
}
try
{
// DynamicInvoke 动态调用（后期绑定）由当前委托所表示的方法
Object result = d.DynamicInvoke(callbackArgs);
Console.WriteLine(d.Method.Name + " result:" + result);
}
catch (TargetParameterCountException)
{
Console.WriteLine("Incorrect number of parameters specified.");
Console.Read();
return;
}
Console.ReadKey();
#endregion
#region
/*
DelegateEx.Excute();
Console.Read();
*/
#endregion
}
}
}