C#之委托与事件（转载）

委托

1.  委托是事件的基础，使用关键字delegate，通过委托与命名方法或匿名方法关联，可以实现委托的实例化。必须使用具有兼容返回类型和输入参数的方法或 lambda 表达式实例化委托。

private static void EnglishGreet(string name)
        {
            System.Console.WriteLine("Greeting ," + name);
        }
        private static void ChineseGreet(string name)
        {
            System.Console.WriteLine("你好 ," + name);
        }

委托：

public delegate void GreetDeletegate(string name);

对比可知，委托参数列表，返回值类型都与函数类型完全一致。

2. 委托作为方法的参数（重点）

private static void GreetPeople(string name, GreetDeletegate MakeGreeting)

{
            MakeGreeting(name);
        }

当给委托变量选择赋不同的值，就会选择不同方法。（之所以可以给委托变量赋值，是因为它可以替代与委托形式一致）

在主函数中调用GreetPeople（）方法，参数不同，就可以委托不同的方法：

GreetPeople("Jimmy Zhang", EnglishGreet);
    GreetPeople("张子阳", ChineseGreet);

委托像变量一样，那么也可直接进行赋值，

如在主函数中这样写：

GreetDeletegate DeleGate1，DeleGate2；

DeleGate1 = EnglishGreet；

DeleGate2 = ChineseGreet；

上述代码还可以进行简化，只定义一个委托变量，将多个方法一次绑定，+= 符号

GreetingDelegate delegate1;
    delegate1 = EnglishGreeting; // 先给委托类型的变量赋值
    delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个方法

// 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
    delegate1 ("Jimmy Zhang");   
    Console.ReadKey();

3. 实现范例的Observer设计模式

.Net Framework的编码规范：

1.委托类型的名称都应该是EventHandler结束。

2.委托原型定义：有一个Void返回值，接受两个各参数，一个是Object类型，一个EventArgs或者是派生型。

3.事件的命名为委托去掉EventHandler之后剩余部分。

4.继承自EventArgs的类型应该以EventArgs结尾。

补充：

1. 委托声明原型中的Object类型的参数代表了Subject，也就是监视对象，在本例中是 Heater(热水器)。回调函数(比如Alarm的MakeAlert)可以通过它访问触发事件的对象(Heater)。
2. EventArgs 对象包含了Observer所感兴趣的数据，在本例中是temperature。

class Heater
    {
        private int temperature;
        public delegate void BoilHandler(int param);
        public event BoilHandler BoilEvent;

        //烧水
        public void BoilWater()
        {
            for(int i = 0;i<=100;i++)
            {
                temperature = i;
                if(temperature>=95)
                {
                    if (BoilEvent != null)
                        BoilEvent(temperature);
                      
                }
            }
        }
    }
    //警报器
    public class Alarm
    {
        public void MakerAlarm(int param)
        {
            Console.WriteLine("Alarm : 滴滴，水已经{0}度了 ：",param);
        }
    }

    //显示器
    public class DisPaly
    {
        public static void ShowMsg(int param)
        {
            Console.WriteLine("Display: 水烧开了，当前温度：{0}", param);
        }

    }

 static void Main(string[] args)
        {
            Heater heater = new Heater();
            Alarm alarm = new Alarm();

            heater.BoilEvent += alarm.MakerAlarm;  //注册方法
            heater.BoilEvent += (new Alarm()).MakerAlarm;
            heater.BoilEvent += DisPaly.ShowMsg;

            heater.BoilWater();  //烧水，会自动调用注册过对象的方法
            Console.ReadKey();
        }

上述实例也可以用如下表示，在螺丝机项目中委托与事件采用的类似编程：

static void Main(string[] args)
        {
            Heater heater = new Heater();
            Alarm alarm = new Alarm();

            heater.Boiled += alarm.MakeAlert;   //注册方法
            heater.Boiled += (new Alarm()).MakeAlert;      //给匿名对象注册方法
            heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert);    //也可以这么注册
            heater.Boiled += Display.ShowMsg;       //注册静态方法

            heater.BoilWater();   //烧水，会自动调用注册过对象的方法
        }

 

 

   public class Heater
    {
        private int tempurater;
        public string type = "RealFire 001";   // 添加型号作为演示
        public string area = "China Xian";   // 添加产地作为演示

        //声明委托
        public delegate void BoiledEventHandler(Object sender, BoiledEventArgs e);
        public event BoiledEventHandler Boiled; //声明事件

 

        public class BoiledEventArgs:EventArgs
        {
            public readonly int temperature;
            public BoiledEventArgs(int temperature)
            {
                this.temperature = temperature;
            }
        }

        // 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视
        protected virtual void OnBoiled(BoiledEventArgs e)
        {
            if (Boiled != null)
            { // 如果有对象注册
                Boiled(this, e);  // 调用所有注册对象的方法
            }
        }
        // 烧水。
        public void BoilWater()
        {
            for (int i = 0; i <= 100; i++)
            {
                tempurater = i;
                if (tempurater > 95)
                {
                    //建立BoiledEventArgs 对象。
                    BoiledEventArgs e = new BoiledEventArgs(tempurater);
                    OnBoiled(e);  // 调用 OnBolied方法
                }
            }
        }
    }
    // 警报器
    public class Alarm
    {
        public void MakeAlert(Object sender, Heater.BoiledEventArgs e)
        {
            Heater heater = (Heater)sender;     //这里是不是很熟悉呢？
                                                //访问 sender 中的公共字段
            Console.WriteLine("Alarm：{0} - {1}: ", heater.area, heater.type);
            Console.WriteLine("Alarm: 嘀嘀嘀，水已经 {0} 度了：", e.temperature);
            Console.WriteLine();
        }
    }

    // 显示器
    public class Display
    {
        public static void ShowMsg(Object sender, Heater.BoiledEventArgs e)
        {   //静态方法
            Heater heater = (Heater)sender;
            Console.WriteLine("Display：{0} - {1}: ", heater.area, heater.type);
            Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", e.temperature);
            Console.WriteLine();
        }
    }

^{此例需要加深对它的理解！！！！！！}