c#事件实例一

c#事件实例一Observe设计模式；

Observe设计模式是为了定义对象之间一种一对多的额依赖关系，以便当一个对象的状态改变时，
其他依赖于它的对象会被自动告知并更新，是一种解耦的设计模式滴呀；

subject：它往往包含其他对象所感兴趣的内容，在本例子中，热水器就是一个监视对象，
Observer：监视者，它监视Subject，当Subject中的某件事发生的时候，会告知Observer，而Observer则会采取相应的行动。
在本范例中，Observer有警报器和显示器，它们采取的行动分别是发出警报和显示水温。

第一种方式（不用委托和事件）

    //热水器
    public class Heater
    {
        private int temperature;
        //申明一个报警器对象  Heater 中申明了一个alarm的对象，那么耦合性争抢了
        Alarm alarm = new Alarm();

        public string type = "x05";
        public string area = "china chengdu";
        //烧水
        public void BoilWater()
        {
            for (int i = 0; i < 100; i++)
            {
                temperature = i;
                if (temperature > 95)
                {
                    //把方法写在了内部，如过新的方法要扩展呢？ 又到内部来添加方法?
                    //如何这个内被编译成了dll 文件 提供给被人调用，当要添加新的方法，又增么办呢?
                    //最好的做法，将添加方法的“方法”暴露在外面。
                    alarm.MakeAlert(temperature);
                    Display.ShowMsg(temperature);  //耦合性增强了 
                   
                }
            }
           
        }

    }

    //警报器
    public class Alarm
    {
        public void MakeAlert(int param)
        {
            Console.WriteLine("alarm：滴滴滴，水温已经{0}度了",param);
        }

    }

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

    }

    class Program
    {
        static void Main(string[] args)
        {
            Heater heater = new Heater();
            heater.BoilWater();
            Console.ReadLine();
        }
    }
}

第二种方式（用委托和事件）

namespace EventLearn
{
    //热水器
    public class Heater
    {
        private int temperature;
        public delegate void BoilHandler(int param); //申明委托
        public event BoilHandler BoilEvent;          //申明事件

        public string type = "x05";
        public string area = "china chengdu";
        //烧水
        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 MakeAlert(int param)
        {
            Console.WriteLine("alarm：滴滴滴，水温已经{0}度了",param);
        }

    }

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

    }

    class Program
    {
        static void Main(string[] args)
        {
            Heater heater = new Heater();
            Alarm alarm = new Alarm();
            heater.BoilEvent += alarm.MakeAlert; //注册方法 
            heater.BoilEvent += Display.ShowMsg;
            //把添加方法的“方法”，“行为暴露在类的外部” 这样就有很高的扩展型，也减少了类之间的耦合
            heater.BoilWater();
            Console.ReadLine();
        }
    }
}

那么问题又来了！

如果我们不光想获得热水器的温度，还想在Observer端(警报器或者显示器)方法中获得它的生产日期、型号、价格，那么委托和方法的声明都会变得很麻烦，而如果我们将热水器的引用传给警报器的方法，就可以在方法中直接访问热水器了。

net中事件的规范：

1.委托的申明都应该以EventHandler结束。
2.委托的原型定义：有一个void返回值，并接受两个输入参数，一个object类型，一个eventArgs类型（或者继承自eventArgs）。
3.事件的命名为委托去掉EventHandler之后剩余的部分。
4.继承自EventArgs的类应该以EventArgs结尾。

第三种实现方式（优化）

    public class Heater
    {
        private int temperature;
        public delegate void BoilHandler(Object sender,BoiledEventArgs e); //申明委托
        public event BoilHandler Boil;          //申明事件

        public string type = "x05";
        public string area = "china chengdu";

        //定义一个BoiledEventArg类，传递给Observe所感兴趣的参数
        public class BoiledEventArgs:EventArgs
        {
            public readonly int temperature;
            public BoiledEventArgs(int tem)
            {
                this.temperature=tem;
            }
        }

        //可以提供继承自Heater的类的重写，以便类继承类其它对象对它的监视；
        protected virtual void OnBoiled(BoiledEventArgs e)
        {
            if (Boil != null)  //如果注册对象不为空
            {
                Boil(this,e); //调用所有注册对象的方法
            }
        }

        //烧水
        public void BoilWater()
        {
            for (int i = 0; i < 100; i++)
            {
                temperature = i;
       
                if (temperature > 95)
                {
                    //建立一个EventArgs对象
                    BoiledEventArgs e = new BoiledEventArgs(temperature);
                    OnBoiled(e); //调用
                }
            }
           
        }

    }

    //警报器
    public class Alarm
    {
        public void MakeAlert(Object sender, Heater.BoiledEventArgs e)
        {
            Heater heater = (Heater)sender;
            Console.WriteLine("这里我们就可以获取包含事件类 中的各种信息，如："+heater.type);
            Console.WriteLine("alarm：滴滴滴，水温已经{0}度了",e.temperature);
        }

    }

    //显示器
    public class Display
    {
        public static void ShowMsg(Object sender, Heater.BoiledEventArgs e)
        {
            Heater heater = (Heater)sender;
            Console.WriteLine("这里我们就可以获取包含事件类 中的各种信息，如：" + heater.type);
            Console.WriteLine("DisPlay：水开了，当前温度{0}",e.temperature);
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            Heater heater = new Heater();
            Alarm alarm = new Alarm();
            heater.Boil += alarm.MakeAlert; //注册方法 
            heater.Boil += Display.ShowMsg;
            //把添加方法的“方法”，“行为暴露在类的外部” 这样就有很高的扩展型，也减少了类之间的耦合

            heater.BoilWater();

            Console.ReadLine();
        }
    }
}

参考文献：张子阳：http://www.cnblogs.com/JimmyZhang/archive/2007/09/23/903360.html#3332956