2014-5-20每日一敲--委托事件Lambda

 一：委托

namespace _01委托
{
    /// <summary>
    /// //委托是什么，委托就是方法指针的容器，简单来说，就是方法容器。
    /// </summary>
    //1.0 首先定义一个委托
    public delegate string DG_say();
}

        /// <summary>
        /// 2.0 方法，签名和DG_say委托一样
        /// </summary>
        public string SayHi()
        {
            return "Hi!";
        }

        public string SayHello()
        {
            return "Hello！";
        }

        //3.0调用委托，将方法当成参数传递
        protected void Page_Load(object sender, EventArgs e)
        {
//实例化一个委托时候，一定要有一个相同签名的方法作为参数
            DG_say Hi = new DG_say(SayHi);
            //向委托添加一个方法
            Hi += SayHello;
            //想委托减少一个方法
            Hi -= SayHi;
            //调用委托
            Response.Write(Hi());
        }

 Hello！

二：事件

namespace WebApp
{
    /// <summary>
    /// 因为委托 += / -= 的赋值太过直接很容易清空对象比如
    /// Hi = null
    /// 所以出现了事件，事件是对委托的一个约束
    /// </summary>
    //1.0 首先定义一个委托
    public delegate string DG_say();
}

namespace WebApp
{
    /// <summary>
    /// 2.0创建使用事件的对象
    /// </summary>
    public class Person
    {
        
        /// <summary>
        /// 创建事件
        /// </summary>
        public event DG_say event_DG_say;

        /// <summary>
        /// 调用事件
        /// </summary>

　　　　　public string ExecutedgSayHiEvent()
        {
            //return event_DG_say.Invoke();
            // or
            return event_DG_say();//调用的是事件生成的委托
        }
　　　　}
 }

        /// <summary>
        /// 3.0与委托一致签名的方法
        /// </summary>
        /// <returns></returns>
        public string SayHi()
        {
            return "Hi!";
        }

        /// <summary>
        /// 4.0调用
        /// </summary>
        protected void Page_Load(object sender, EventArgs e)
        {
            Person p = new Person();
            //在外面给委托添加方法时候，只能调用事件的接口
            //而且 只能是方法
            p.event_DG_say += SayHi;
            //p.event_DG_say = null; (报错)
            Response.Write(p.ExecutedgSayHiEvent());
        }

Hi！

事件的作用是给委托加个保障，犹如属性器一样，事件编译过后，最终将会

　　　　　 /*
         * public event DGSayHi dgSayHiEvent;
         * 做了两件事情
         * 1.申明了一个private DGSayHi dgSayHiEvent;私有委托
         * 2.创建了一个public Event DGSayHi dgSayHiEvent事件
         * 利用 Reflector 反编译，所看到的为
         * private DGSayHi dgSayHiEvent;
         * public Event DGSayHi dgSayHiEvent
         * {
         *      add{····}
         *      remove{···}
         * }
         * 其实，事件就是委托的属性访问器。就像 get,set 那样，所以在外部不能直接dgSayHiEvent();或者dgSayHiEvent.Invoke();
         */

 

三：Lanmbda

 

namespace WinApp
{

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        /// <summary>
        /// 1.0 有一个add的委托
        /// </summary>
        public delegate int DG_Add(int x, int y);

        private void button1_Click(object sender, EventArgs e)
        {
            //3.0使用方法
            DG_Add add = new DG_Add(Add);
            MessageBox.Show(add(13, 12).ToString());//25

            //3.1试用匿名方法
            DG_Add add_nm = delegate(int x, int y) { return x + y; };
            MessageBox.Show(add_nm(10, 11).ToString());//21

            //3.2使用Lanmbda语句1
            //简单的把delegate去掉，在()与{}之间加上  "=>"。
            DG_Add add_l1 = (int x, int y) => { return x + y; };
            MessageBox.Show(add_l1(10, 10).ToString());//20


            //3.3使用Lanmbda语句2
            //在方法3.2的基础上把参数类型都干掉了
            DG_Add add_l2 = (x, y) => { return x + y; };
            MessageBox.Show(add_l2(8, 8).ToString());//16


            //3.4使用Lanmbda表达式
            //把{},以及return关键字都去掉了
            DG_Add add_l3 = (x, y) => x + y;
            MessageBox.Show(add_l3(5, 5).ToString());

            //Lambda 语句与 Lambda 表达式类似，只是语句括在大括号中： 
            //(input parameters) => {statement;} 
            //而表达式是这样子的
            //(input parameters) => expression 

        }
        /// <summary>
        /// 2.0方法
        /// </summary>
        public int Add(int x, int y)
        {
            return x + y;
        }
    }
}

 

 

四：利用委托查找最大值

 --平时的做法

 

        private void button1_Click(object sender, EventArgs e)
        {
            //数据
            int[] intArr = { 12, 345, 23, 64, 321, 73, 577, 34, 46, 546 };
            int intMax = 0;
            for (int i = 0; i < intArr.Length; i++)
            {
                if (IsMax(intArr[i], intMax))
                {
                    intMax = intArr[i];
                }
            }
            MessageBox.Show(intMax.ToString());
        }

        /// <summary>
        /// 比较方法
        /// </summary>
        public bool IsMax(int x, int y)
        {
            //对比，如果x大，返回true
            return x > y;
        }

577

 

--利用泛型和委托

    /// <summary>
    /// 1.0 泛型委托，将具体的比对类型传入比对方法中
    /// </summary>
    public delegate bool Dg_Compare<T>(T T1, T T2);

        /// <summary>
        /// 2.0 泛型方法比大小
        /// Tarr数据 dgCompare 委托占位，具体的实现方法是IsMax
        /// </summary>
        public T GetMax<T>(T[] Tarr, Dg_Compare<T> dgCompare)
        {
            T Max = Tarr[0];
            //这里只是一个循环作用
            foreach (var item in Tarr)
            {
                // X > Y ==> true
                // 正真的比对
                if (dgCompare(item, Max))
                {
                    Max = item;
                }
            }
            return Max;
        }

        /// <summary>
        /// 3.0真正的比较方法
        /// </summary>
        public bool IsMax(int x, int y)
        {
            //对比，如果x大，返回true
            return x > y;
        }

        /// <summary>
        /// 4.0调用
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            //数据
            int[] intArr = { 12, 345, 23, 64, 321, 73, 577, 34, 46, 546 };
            int intMax = GetMax<int>(intArr, IsMax);
            MessageBox.Show(intMax.ToString());
        }

  有了这个方法之后，什么类型的取最大值，都显得起而一举了

 ----取最大年龄者

 --这个不需要改动

    /// <summary>
    /// 1.0 泛型委托，将具体的比对类型传入比对方法中
    /// </summary>
    public delegate bool Dg_Compare<T>(T T1, T T2);

--这个也不需要改动

        /// <summary>
        /// 2.0 泛型方法比大小
        /// Tarr数据 dgCompare 委托占位，具体的实现方法是IsMax
        /// </summary>
        public T GetMax<T>(T[] Tarr, Dg_Compare<T> dgCompare)
        {
            T Max = Tarr[0];
            //这里只是一个循环作用
            foreach (var item in Tarr)
            {
                // X > Y ==> true
                // 正真的比对
                if (dgCompare(item, Max))
                {
                    Max = item;
                }
            }
            return Max;
        }

 --需要变动的是，真正比对的方法和调用，毕竟字段类型不一样

        /// <summary>
        /// 3.0真正的比较方法, 前者是否大于后者
        /// </summary>
        public bool IsMax(Person x, Person y)
        {
            return x.Age > y.Age;
        }

        /// <summary>
        /// 4.0调用
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            //集合初始化器
            Person[] PerArr = { 
                                  new Person() { Name = "AA", Age = 22 }, 
                                  new Person() { Name = "BB", Age = 34 }, 
                                  new Person() { Name = "CC", Age = 65 }, 
                                  new Person() { Name = "DD", Age = 33 }, 
                                  new Person() { Name = "EE", Age = 78 }
                              };
            Person MaxAgeOfPerson = GetMax<Person>(PerArr, IsMax);
            MessageBox.Show(MaxAgeOfPerson.Name + ":   " + MaxAgeOfPerson.Age.ToString());

        }

 

委托的各个试用

1.--一般委托

    /// <summary>
    /// 1.0 委托
    /// </summary>
    public delegate string Dg_Say();

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Dg_Say Say = new Dg_Say(SayHi);
            MessageBox.Show(Say());
        }
        /// <summary>
        /// 2.0 方法
        /// </summary>
        public string SayHi()
        {
            return "Hi！";
        }
    }

2.--匿名方法

namespace WinApp
{
    /// <summary>
    /// 1.0 委托
    /// </summary>
    public delegate string Dg_Say();

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //匿名方法
            Dg_Say SayHello = delegate() { return "Hello!"; };
            MessageBox.Show(SayHello());
        }

    }
}

3.--Lambda语句 与 Lambda 表达式类似，只是语句括在大括号中：
　　　　(input parameters) => {statement;}

namespace WinApp
{
    /// <summary>
    /// 1.0 委托
    /// </summary>
    public delegate string Dg_Say();

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //匿名方法
            Dg_Say SayHello = () => { return "Hi, Hello!"; };
            MessageBox.Show(SayHello());
        }

    }
}

4.--func 委托 有参数有返回值

namespace WinApp
{

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //Func Lambda语句
            Func<string, string> SayHi = (name) => { return "Hi! " + name; };
            MessageBox.Show(SayHi(" Func<string, string>Lambda委托"));

            //Func 匿名委托
            Func<string, string> SayHello = delegate(string name)
            {
                return "Hello! " + name;
            };
            MessageBox.Show(SayHello("Func<string, string>匿名委托"));
        }

    }
}

5.--Action 委托 有参数无返回值

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Action<string> SayHi = (Hi) =>
            {
                MessageBox.Show(Hi);
            };

            Action<string> SayHello = delegate(string Hello)
            {
                MessageBox.Show(Hello);
            };

            SayHi("Hi!");

            SayHello("Hello!");
        }

    }