委托初体验

什么是委托
”委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。“

• 委托是一个类,所以他是定义在类级别上的,也就是和类同级别的，这个类保存了一个对象和这个对象的一个方法
• 委托的意义就是,把调用委托实际是委托给了一个对象的一个方法。
• 方法不必与委托签名完全匹配。(协变与逆变)，委托就是用来动态代理与其签名相同的方法。函数签名的不同（即参数个数与类型的不同）
• 委托类似于 C++函数指针，但它们是类型安全的

在委托实例前，不加event，那这个委托就是一个普通的委托，我们可以用别的函数调用，也可以直接用对象调用

实现一个delegate是很简单的，通过以下3个步骤即可实现一个delegate：
1． 声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。
2． 创建delegate对象，并”将你想要传递的函数作为参数传入”。
3． 在要实现异步调用的地方，通过上一步创建的对象来调用方法。

例如

public class MyDelegateTest
{
        // 步骤1，声明delegate对象
        public delegate void MyDelegate(string name);

        // 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型
        public static void MyDelegateFunc(string name)
        {
                  Console.WriteLine("Hello, ", name);
        }
        public static void Main()
        {
                  // 步骤2，创建delegate对象(实例？？)
         MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);
                 // 步骤3，调用delegate
                 md("sam1111");
        }
}

输出结果是：Hello, sam1111

 class Program
    {
        // 声明委托类型CalcCallback,原型如下：
        public delegate double CalcCallback(double x, double y);

        static void Main(string[] args)
        {
            // 下面使用3种方式初始化一个委托对象，前提
            // 就是方法的签名与委托类型声明时的签名一样即可

            // 1、使用命名方法方式初始化一个委托对象
            CalcCallback add = new CalcCallback(Sum);

            // 2、使用拉姆达函数方式初始化一个委托对象
            CalcCallback sub = (x, y) =>
            {
                return x - y;
            };

            // 3、使用匿名函数方式初始化一个委托对象
            CalcCallback mul = delegate(double x, double y)
            {
                return x * y;
            };

            Console.WriteLine(add(1, 2));//显示结果是3
            Console.WriteLine(sub(2, 1));//显示结果是1
            Console.WriteLine(mul(2, 2));//显示结果是4

            Console.ReadKey(true);
        }
        static double Sum(double x, double y)
        {
            return x + y;
        }
    }

3
1
4
上面的是控制台应用程序打印出来的效果

C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：
public delegate void MyEventHandler(object sender, MyEventArgs e);
其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。

事件与委托的联系和区别

• 事件是一种特殊的委托的实例，或者说是受限制的委托，是委托一种特殊应用，在类的外部只能施加+=,-=操作符，二者本质上是一个东西。
• delegate关键字类比于class关键字, 定义的是一种委托类型,然后再创建委托示例.
  创建委托实例时, 用event关键字来修饰就变成了创建一个事件. 也就是事件是一种特殊的委托.

自定义事件

• 要创建一个事件驱动的程序需要下面的步骤：
  
  1. 声明关于事件的委托；
  2. 声明事件；
  3. 编写触发事件的函数；
  4. 创建事件处理程序；
  5. 注册事件处理程序；
  6. 在适当的条件下触发事件。

下面是例子

class Dog
{
    //1.声明关于事件的委托；
    public delegate void AlarmEventHandler(object sender, EventArgs e);

    //2.声明事件；   
    public event AlarmEventHandler Alarm;

    //3.编写引发事件的函数；
    public void OnAlarm()
    {
        if (this.Alarm != null)
        {
            Console.WriteLine("/n狗报警: 有小偷进来了,汪汪~~~~~~~");
            this.Alarm(this, new EventArgs());   //发出警报
         }
    }
}

//事件接收者
class Host
{
    //４.编写事件处理程序
    void HostHandleAlarm(object sender, EventArgs e)
    {
        Console.WriteLine("主  人: 抓住了小偷！");
    }

    //５.注册事件处理程序
    public Host(Dog dog)
    {
        dog.Alarm += new Dog.AlarmEventHandler(HostHandleAlarm);
    }
}

//６.现在来触发事件
class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog();
        Host host = new Host(dog);

        //当前时间，从2008年12月31日23:59:50开始计时
        DateTime now = new DateTime(2008, 12, 31, 23, 59, 50);
        DateTime midnight = new DateTime(2009, 1, 1, 0, 0, 0);

        //等待午夜的到来
        Console.WriteLine("时间一秒一秒地流逝... ");
        while (now < midnight)
        {
            Console.WriteLine("当前时间: " + now);
            System.Threading.Thread.Sleep(1000);   //程序暂停一秒
            now = now.AddSeconds(1);                //时间增加一秒
         }

        //午夜零点小偷到达,看门狗引发Alarm事件
        Console.WriteLine("/n月黑风高的午夜: " + now);
        Console.WriteLine("小偷悄悄地摸进了主人的屋内... ");
        dog.OnAlarm();
    }
} 

• 注意:.Net提供自带的事件委托类型列表内容EventHandler

(msdn：http://msdn.microsoft.com/zh-cn/library/system.eventhandler.aspx)
利用EventHandler,可以直接声明对象事件，免去自定义委托的声明