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();

上述委托发现可以随意对其赋值(public)破坏了类的封装性如果private在别类中就不可现，为解决此种现象使用关键字event,注册方法时只能使用+=；

 public partial class Greet : Form
    {
        public Greet()
        {
            InitializeComponent();
        }
        //定义委托，表示该委托可以代表的方法的类型
       // public delegate void GreetingDelegate(string name);
       
        private void EnglishGreeting(string name)
        {
            MessageBox.Show("Morning " + name);
        }

        private void ChineseGreeting(string name)
        {
            MessageBox.Show("早上好 " + name);
        }

        //注意此方法接受一个GreetingDelegate 类型的方法作为参数
       
        //private void GreetPeople(string name,GreetingDelegate greeting )
        //{
        //    //name = this.textBox1.Text;
        //    greeting(name);
        //}

        private void button1_Click(object sender, EventArgs e)
        {
            //真的很像指针
            //GreetPeople("Jimy Zhang", EnglishGreeting);
            //GreetPeople("张 子 扬", ChineseGreeting);

            //GreetingDelegate GreetDelegateChinese = ChineseGreeting;  //对委托可以随意赋值
            //GreetDelegateChinese += EnglishGreeting;
            //GreetDelegateChinese("Jimmy Zhang");

            DelegateTest test = new DelegateTest();
            test.greet += EnglishGreeting; //在类DelegateTest中声明委托greet使用的事件这样就可以能避免在类外随意对他赋值，使用event注册只能使用+=了
            test.GreetPeople("Jimy Zhang");
        }
    }

    public class DelegateTest
    {
        public delegate void delegateGreet(string name);
        public event delegateGreet greet;
        public void GreetPeople(string name)
        {
            if(greet!=null)
            {
                greet(name);
            }
        }
    }

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();
        }
    }

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

 

 

       

转载于:https://www.cnblogs.com/xingyuanzier/p/10350343.html