C# 中的委托事件和回调函数

委托
委托通俗的讲就是将自己所不能做的事情交给其他人去做，但怎样才知道帮你做事情的人的名字呢，因此需要名字这个和特性。
简单的委托
在C#中委托就像是一个函数的指针，在程序运行时可以使用他们来调用不同的函数。首先是委托存储了方法名，还有参数列表(方法签名)，以及返回的类型：

delegate string ProcessDelegate(int i);

在程序中使用委托来运行程序的话，需要满足以下几点：

1. 返回类型和委托的返回类型必须一致；
2. 参数保持一致；
   例如：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 委托
{
    /// <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)
        {
            ProcessDelegate pd = new ProcessDelegate(new Test().Process);
            Console.WriteLine(pd("Text1","Text2"));
            Console.ReadKey();
        }
    }

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

输出的结果就是：

Text1Text2

2泛型委托
泛型就是值参数的类型不确定，将上面的代码改写如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 委托
{
    /// <summary>
    /// 委托的声明
    /// </summary>
    /// <param name="s1"></param>
    /// <param name="s2"></param>
    /// <returns></returns>
    public delegate string ProcessDelegate<T,S>(T s1, S s2);
    class Program
    {
        static void Main(string[] args)
        {
            ProcessDelegate<string,int> pd = new ProcessDelegate<string,int>(new Test().Process);
            Console.WriteLine(pd("Text1",2));
            Console.ReadKey();
        }
    }

    public class Test
    {
        public string Process(string s1, int s2)
        {
            return s1 + s2.ToString();
        }
    }
}

输出的结果为：

Text12

事件
事件指当某件事情发生时一个对象可以通过事件通知另外一个对象，可以把事件看成是一个时间节点去触发另外一件事情，而另外一件事情怎么去做，他不会关心。事件的关键点在于什么时候让谁去做。在C#中定义事件的关键字是event.例如：event ProcessDelegate ProcessEvent;

using System;
using System.Collections.Generic;
using System.Text;

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("The method or operation is not implemented.");
        }

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

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

回调函数
回调函数就是把一个方法传给另一个方法去执行：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 回调函数
{
    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);
            Console.ReadKey();
        }
    }

    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 s1 + s2;
        }
    }
}