事件，委托，回调函数个人理解

PS：本文来自网友：yurow birdshover  原文URL：http://www.cnblogs.com/birdshover/archive/2008/01/07/1029471.html

一、事件

在某件事情发生时，一个对象可以通过事件通知另一个对象。

代码实例

namespace TestApp
{
    /// <summary>
    /// 委托
    /// </summary>
    /// <param name="s1"></param>
    /// <param name="s2"></param>
    /// <returns></returns>
    public delegate void ProcessDelegate(object sender, EventArgs e);

    class Program
    {
        

        static void Main(string[] args)
        {
            /*  第一步执行  */
            Test t = new Test();
            /* 关联事件方法，相当于寻找到了委托人 */
            t.ProcessEvent += new ProcessDelegate(t_ProcessEvent);
            /* 进入Process方法 */
            Console.WriteLine(t.Process()); 

            Console.Read();
        }

        static void t_ProcessEvent(object sender, EventArgs e)
        {
            Test t = (Test)sender;
            t.Text1 = "Hello";
            t.Text2 = "World";
        }
    }

    public class Test
    {
        private string s1;

        public string Text1
        {
            get { return s1; }
            set { s1 = value; }
        }

        private string s2;

        public string Text2
        {
            get { return s2; }
            set { s2 = value; }
        }


        public event ProcessDelegate ProcessEvent;

        void ProcessAction(object sender, EventArgs e)
        {
            if (ProcessEvent == null)
                ProcessEvent += new ProcessDelegate(t_ProcessEvent);
            ProcessEvent(sender, e);
        }

        //如果没有自己指定关联方法，将会调用该方法抛出错误
        void t_ProcessEvent(object sender, EventArgs e)
        {
            throw new Exception("方法或操作未实现。");
        }

        void OnProcess()
        {
            ProcessAction(this, EventArgs.Empty);
        }

        public string Process()
        {
            OnProcess();
            return s1 + s2;
        }
    }
}

输出的结果是:
HelloWorld
 

二、委托

委托就像一个函数的指针，在程序运行时可以使用它们来调用不同的函数。

namespace  TestApp
 6  {
 7       ///   <summary>
 8       ///  委托
 9       ///   </summary>
10       ///   <param name="s1"></param>
11       ///   <param name="s2"></param>
12       ///   <returns></returns>
13       public   delegate   string  ProcessDelegate( string  s1,  string  s2);
14 
15       class  Program
16      {
17           static   void  Main( string [] args)
18          {
19               /*   调用方法   */
20              ProcessDelegate pd  =   new  ProcessDelegate( new  Test().Process);
21              Console.WriteLine(pd( " Text1 " ,  " Text2 " ));
22          }
23      }
24 
25       public   class  Test
26      {
27           ///   <summary>
28           ///  方法
29           ///   </summary>
30           ///   <param name="s1"></param>
31           ///   <param name="s2"></param>
32           ///   <returns></returns>
33           public   string  Process( string  s1, string  s2)
34          {
35               return  s1  +  s2;
36          }
37      }
38  }

输出的结果是:
Text1Tex2

ps：委托方法ProcessDelegate（）和被调用方法Process（）的签名必须一致。

Main方法Process方法视为A层，ProcessDelegate视为B层，A层调用B层，B层调用A层的Process。

三、回调函数

回调函数就是把一个方法的传给另外一个方法去执行（如异步）

代码实例

namespace TestApp
{
    /// <summary>
    /// 委托
    /// </summary>
    /// <param name="s1"></param>
    /// <param name="s2"></param>
    /// <returns></returns>
    public delegate string ProcessDelegate(string s1, string s2);

    class Program
    {
        static void Main(string[] args)
        {
            /*  调用方法  */
            Test t = new Test();
            string r1 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process1));
            string r2 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process2));
            string r3 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process3));

            Console.WriteLine(r1);
            Console.WriteLine(r2);
            Console.WriteLine(r3);
        }
    }

    public class Test
    {
        public string Process(string s1,string s2,ProcessDelegate process)
        {
            return process(s1, s2);
        }

        public string Process1(string s1, string s2)
        {
            return s1 + s2;
        }

        public string Process2(string s1, string s2)
        {
            return s1 + Environment.NewLine + s2;
        }

        public string Process3(string s1, string s2)
        {
            return s2 + s1;
        }
    }
}