Lession07 委托、事件、匿名方法和lambda表达式

委托：

 /*
     * 委托是一种数据类型（既然是数据类型，就可以定义变量），就是用来存储方法的
     * 语法：[访问修饰符] delegate 返回类型 委托名();
     * 
     * 
     */

using System;

namespace ConsoleApp1    //委托
{
    /*
    * 委托是一种数据类型（既然是数据类型，就可以定义变量），就是用来存储方法的
    * 语法：[访问修饰符] delegate 返回类型 委托名();
    * 
    * 
    */
    class Program
    {
        static void Main(string[] args)
        {
            //Myclass mc = new Myclass();
            //2.使用委托
            //声明一个委托变量md，并且new了一个委托对象，把方法M1传递了进去，即md委托保存了M1方法
            MyDelegate md = new MyDelegate(M1);
            //3.调用md委托的时候，就相当于调用了M1方法
            M1();
            Console.WriteLine("------------------");
            //实例化MachCal类
            MachCal mc = new MachCal();
            //实例化委托
            CallBack cb = new CallBack(mc.Plus);
            //调用这个委托
            int res = cb(10, 20);
            Console.WriteLine();
            Console.WriteLine("res的值是：{0}", res);

            Console.ReadKey();
        }
        static void M1()
        {
            Console.WriteLine("我是一个没有返回值没有参数的方法");
        }
    }
    //定义委托
    //定义了一个委托类型，用来保存无参数，无返回值的方法
    //定义了一个名字叫MyDelegate的类型，并且这个类型是个委托，而且只能存储
    //没有返回值，没有参数的方法
    //委托要定义在命名空间中和类是同一级别
    public delegate void MyDelegate();
    //定义一个MyClass的一个类型
    public class Myclass
    {

    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1           //委托
{
    //1.定义委托
    public delegate int CallBack(int n1,int n2);
    class MachCal
    {
        //两个整数类型相加
        public int Plus(int num1,int num2)
        {
            return num1 + num2;
        }
        //两个整数类型相减
        public int Minus(int num1,int num2)
        {
            return num1 - num2;
        }

    }
}

 

 

 事件：

 /*
     * 事件是基于委托
     * C#中事件的处理步骤
     * 1.定义事件
     * [访问修饰符] event 委托名 事件名
     * 2.订阅事件
     * 事件名 += new 委托（事件处理方法名）
     * 3.事件发生时，通知订阅者发生的事件
     * 事件名（[参数列表]）；
     * 
     */

//1.定义一个委托和一个事件
        public delegate void Study();
        public event Study StudyEvent;

using System;

namespace ConsoleApp1     //事件
{
    /*
    * 事件是基于委托
    * C#中事件的处理步骤
    * 1.定义事件
    * [访问修饰符] event 委托名 事件名
    * 2.订阅事件
    * 事件名 += new 委托（事件处理方法名）
    * 3.事件发生时，通知订阅者发生的事件
    * 事件名（[参数列表]）；
    * 
    */
    public class Teacher
    {//写在事件源里
        //1.定义一个委托和一个事件
        public delegate void Study();
        public event Study StudyEvent;
        public void Beginclass()
        {
            Console.WriteLine("开始上课啦");
            if (StudyEvent !=null)
            {
                StudyEvent();//引发事件
            }
        }

    }
    public class Student
    {
        private string stuName;
        public Student(string name )
        {
            this.stuName = name;
        }
        public void Listener()
        {
            Console.WriteLine("学生{0}正在认真听课！", stuName);
        }
        public void Record()
        {
            Console.WriteLine("学生{0}正在认真做笔记！", stuName);
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            Teacher t = new Teacher();
            Student s1 = new Student("李腾");
            Student s2 = new Student("赵文凤");
            //2.订阅事件
            t.StudyEvent += new Teacher.Study(s1.Listener);
            t.StudyEvent += new Teacher.Study(s2.Record);
            //触发事件
            t.Beginclass();
            Console.ReadKey();
        }
    }
}

匿名方法和lambda表达式：

 /*
     * 1.委托是一种数据类型，像类一样的一种数据类型，一般都是直接在命名空间中定义
     * 2.定义委托时，需要指明返回值类型，委托名于参数列表，这样就能确定该类型能存储什么样的方法
     * 3.使用委托：
     *         a.声明委托变量
     *         b.委托是个引用类型，像类一样，所以声明委托变量后，如果不赋值则该委托变量为null
     *         所以使用委托变量前最好做非空校验weituo!=null
     *         c.委托类型的变量只能赋值一个委托类型的对象
     * 
     * 匿名方法：
     * 不能直接在类中定义，而是在给委托变量赋值的时候，需要赋值一个方法，此时可以“现做现卖”，
     * 定义一个匿名方法传递给该委托
     * 
     * 语法：
     * 委托类型 委托实例 = delegate([参数列表]){
     *      代码块
     * };
     *
     *lambda表达式
     *委托类型 委托实例=（[参数]）=>{代码块};
     */

using System;

namespace  ConsoleApp1              //匿名方法和Lambda表达式
{
    /*
    * 1.委托是一种数据类型，像类一样的一种数据类型，一般都是直接在命名空间中定义
    * 2.定义委托时，需要指明返回值类型，委托名于参数列表，这样就能确定该类型能存储什么样的方法
    * 3.使用委托：
    *         a.声明委托变量
    *         b.委托是个引用类型，像类一样，所以声明委托变量后，如果不赋值则该委托变量为null
    *         所以使用委托变量前最好做非空校验weituo!=null
    *         c.委托类型的变量只能赋值一个委托类型的对象
    * 
    * 匿名方法：
    * 不能直接在类中定义，而是在给委托变量赋值的时候，需要赋值一个方法，此时可以“现做现卖”，
    * 定义一个匿名方法传递给该委托
    * 
    * 语法：
    * 委托类型 委托实例 = delegate([参数列表]){
    *      代码块
    * };
    *
    *lambda表达式
    *委托类型 委托实例=（[参数]）=>{代码块};
    */
    class Program
    {
        static void Main(string[] args)
        {
            //MyDelegate md = M1;
            MyDelegate md = new MyDelegate(M1);
            md();
            //无参数，无返回值的一个匿名方法
            MyDelegate md1 = delegate ()
            {
                Console.WriteLine("hello,这是一个无参数无返回值的匿名方法写的");
            };
            md1();
            Console.WriteLine("-------------");
            //有参数，无返回值的匿名方法
            MyDelegate2 md2 = delegate (string mgs)
            {
                Console.WriteLine("早上好，{0}", mgs);
            };
            md2("海龙");
            //有参数，无返回值的lambda表达式
            MyDelegate2 md22 = m =>
            {
                Console.WriteLine("中午好，{0}", m);
            };
            md22("干饭吧");
            Console.WriteLine("--------------");
            //有参数，有返回值的匿名方法
            AddDelegate a1 = delegate (int n1, int n2, int n3)
            {
                return n1 + n2 + n3;
            };
            Console.WriteLine("三个整数类型的值的和是{0}", a1(10, 20, 30));
            //有参数，有返回值的lambda表达式
            AddDelegate a2 = (n1, n2, n3) =>
            {
                return n1 + n2 + n3;
            };
            Console.WriteLine("三个整数类型的值的和是{0}", a2(20, 30, 50));

            Console.ReadKey();
        }
        static void M1()
        {
            Console.WriteLine("ok");
        }
    }
    //无返回值，无参数的委托
    public delegate void MyDelegate();
    //无返回值，有参数的委托
    public delegate void MyDelegate2(string msg);
    //有返回值，有参数的委托
    public delegate int AddDelegate(int n1,int n2,int n3);
}