C#---第十七课:委托delegate、匿名函数、Lambda函数、事件的使用

1. 委托的使用基础

1.委托是一个引用，这个引用可以指向不同的函数。最终通过改变指向就可以通过一个委托调用了不同的函数。
2.创建委托的时候，需要确定返回值、参数（类型及参数个数）

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        public static int Addition(int a, int b)
        {
            return a + b;
        }

        public static int Subtraction(int a, int b)
        {
            return a - b;
        }

		// 如下的委托，返回值、参数都与上面两个函数完全一直。最终可以将这个委托指向如上两个函数
        delegate int MyDelegate(int a, int b);

        static void Main(string[] args)
        {
            MyDelegate delegate01 = Addition;
            MyDelegate delegate02 = Subtraction;
            Console.WriteLine(delegate01(1, 3));
            Console.WriteLine(delegate02(5, 2));

            Console.ReadKey();
        }
    }
}

4
3

委托的指向也是可以修改的：

        static void Main(string[] args)
        {
            MyDelegate delegate01 = Addition;
            MyDelegate delegate01 = Subtraction;
            Console.WriteLine(delegate01(3, 1));

            Console.ReadKey();
        }


// 2

2. 委托的应用—将委托委托函数的参数（路由的作用）

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        public static int Addition(int a, int b)
        {
            return a + b;
        }

        public static int Subtraction(int a, int b)
        {
            return a - b;
        }

        delegate int MyDelegate(int a, int b);

        static int Calculate(int a, int b, MyDelegate Cal)
        {
            return Cal(a, b);
        }

        static void Main(string[] args)
        {
            Console.WriteLine(Calculate(3, 1, Subtraction));
            Console.ReadKey();
        }
    }
}

3. 匿名函数—利用委托的函数

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        delegate int MyDelegate(int a, int b);

		// 通过已经创建好的委托，创建函数体
        static MyDelegate MyCal = delegate (int a, int b)
        {
            return a * b;
        };

        static void Main(string[] args)
        {
            Console.WriteLine(MyCal(3, 5));
            Console.ReadKey();
        }
    }
}

// 15

4. Lamda函数

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        delegate int MyDelegate(int a, int b);


		// 注意，通过委托创建的Lamda函数
        static MyDelegate MyCal = (int a, int b) =>
        {
            return a * b;
        };

        static void Main(string[] args)
        {
            Console.WriteLine(MyCal(3, 5));
            Console.ReadKey();
        }
    }
}

// 15

5. 事件 event

事件的本质是一个触发点，最终这个触发点能触发多少个动作，是由这个事件绑定了多少动作决绝的。

namespace AlienDemo
{
    internal class AlienDemoClass
    {
        delegate void MyDelegate(string name);

        static event MyDelegate MyEvent;

        static void Func_01(string name)
        {
            Console.WriteLine("======={0}======", name);
        }
        static void Func_02(string name)
        {
            Console.WriteLine("hello world:{0}", name);
        }

        static void Main(string[] args)
        {
            MyEvent += Func_01;
            MyEvent += Func_02;		// 绑定某个函数
            MyEvent -= Func_02;		// 解绑某个函数
            
            MyEvent("Alien");
            Console.ReadKey();
        }
    }
}


// =======Alien======