[CLR via C#]17. 委托

delegate void Bar(ref Int32 z);

button1.Click += new EventHandle(button1_Click);

void button1_Click(Object sender, EventArgs e) {
    // 按钮单击后要做的事情....
}

button1_Click += button1_Click;

    public sealed class AClass
    {
        private static void CallbackWithoutNewingADelegateObject(){                
            ThreadPool.QueueUserWorkItem(obj => Console.WriteLine(obj),5);
        }
    }

internal sealed class AClass2
    {
        internal static void UsingLocalVariablesInTheCallbackCode(Int32 numToDo)
        {
 
            // 一些局部变量
            Int32[] squares = new Int32[numToDo];
            AutoResetEvent done = new AutoResetEvent(false);
 
            // 在其它线程上执行一系列任务
            for (Int32 n = 0; n < squares.Length; n++)
            {
                ThreadPool.QueueUserWorkItem(
                   delegate(Object obj)
                   {
                       Int32 num = (Int32)obj;
 
                       // 耗时任务
                       squares[num] = num * num;
 
                       // 如果是最后一个任务，则让主线程继续执行
                       if (Interlocked.Decrement(ref numToDo) == 0)
                           done.Set();
                   }, n);
            }
 
            // 等待其他所有线程执行完毕
            done.WaitOne();
 
            // 显示任务
            for (Int32 n = 0; n < squares.Length; n++)
                Console.WriteLine("Index {0}, Square={1}", n, squares[n]);
        }
    }

fb(item);   //item为Int32类型

public abstract class Delegate {
    // 构造用于包装指定静态方法的一个"type"委托
    public static Delegate CreateDelegate(Type type, MethodInfo method);
    public static Delegate CreateDelegate(Type type, MethodInfo method,Boolean throwOnBindFailure);
    
    // 构造用于包装指定实例方法的一个"type"委托
    public static Delegate CreateDelegate(Type type,Object firstArgument, MethodInfo method); //firstArgument指的是this
    public static Delegate CreateDelegate(Type type,Object firstArgument, MethodInfo method,Boolean throwOnBindFailure);
 
    // 调用委托并传递参数
    public Object DynamicInvoke(params Object[] args);
 
}

internal static class DelegateReflection
    {
        // 下面是一些不同的委托定义
        private delegate Object TwoInt32s(Int32 n1, Int32 n2);
        private delegate Object OneString(String s1);
 
        public static void Go(String[] args)
        {
            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);
                return;
            }
 
            // 将delType参数转换为一个委托类型
            Type delType = Type.GetType(args[0]);
            if (delType == null)
            {
                Console.WriteLine("Invalid delType argument: " + args[0]);
                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]);
                return;
            }
 
            // 创建一个数组，其中只包含要通过委托对象传给方法的参数
            Object[] callbackArgs = new Object[args.Length - 2];
 
            if (d.GetType() == typeof(TwoInt32s))
            {
                try
                {
                    // 将String类型的参数转换为Int32类型的参数
                    for (Int32 a = 2; a < args.Length; a++)
                        callbackArgs[a - 2] = Int32.Parse(args[a]);
                }
                catch (FormatException)
                {
                    Console.WriteLine("Parameters must be integers.");
                    return;
                }
            }
 
            if (d.GetType() == typeof(OneString))
            {
                // 只复制String参数
                Array.Copy(args, 2, callbackArgs, 0, callbackArgs.Length);
            }
 
            try
            {
                // 调用委托并显示结果
                Object result = d.DynamicInvoke(callbackArgs);
                Console.WriteLine("Result = " + result);
            }
            catch (TargetParameterCountException)
            {
                Console.WriteLine("Incorrect number of parameters specified.");
            }
        }
 
        // 这个回调方法获取2个Int32类型的参数
        private static Object Add(Int32 n1, Int32 n2)
        {
            return n1 + n2;
        }
 
        // 这个回调方法获取2个Int32类型的参数
        private static Object Subtract(Int32 n1, Int32 n2)
        {
            return n1 - n2;
        }
 
        // 这个回调方法获取1个String类型的参数
        private static Object NumChars(String s1)
        {
            return s1.Length;
        }
 
        // 这个回调方法获取1个String类型的参数
        private static Object Reverse(String s1)
        {
            Char[] chars = s1.ToCharArray();
            Array.Reverse(chars);
            return new String(chars);
        }
    }