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

 

posted @ 2015-12-25 15:21  咕-咚  阅读(1561)  评论(0编辑  收藏  举报