1 委托

1.1 概念

delegate:托类似于函数指针，但更类型安全，是实现事件和回调机制的基础
dalegate：抽象方法的简化  实现把方法作为参数/变量进行传递

1.2 委托的定义和实现

​
/*
      委托的使用 可以当成一种数据类型一样  只是赋值必须是格式和其一样的方法
      委托类型可以当 成员变量+局部变量+方法参数列表
      作用：可以让方法作为变量、参数 进行传递
​
     */
internal class Demo12_delegate和lambda表达式
{
    //成员变量是委托类型
    static Test02.hehe th;
​
​
    static void Main(string[] args)
    {
        //创建子类对象 :调用对象的heeh方法
        Test01Zi zi = new Test01Zi();
        zi.hehe(1);
​
        //使用委托赋值：：：指定委托的实例：：一个方法：：方法要求  返回值类型一样  参数列表一样
        //局部变量是委托
        Test02.hehe t = hh;
        t(1);
​
        //使用委托
        haha(t,11);
        haha(hh, 11);
        haha(new Demo12_delegate和lambda表达式().hhh,11);
​
​
        //给委托赋值:
        Test02.hehe tt = new Demo12_delegate和lambda表达式().hhh;
​
        th = hh;
        th(1);
​
    }
    public static  void hh(int a) {
        Console.WriteLine("a=");
    }
    public  void hhh(int a)
    {
        Console.WriteLine("a=");
    }
    //参数列表是委托类型
    public static void haha(Test02.hehe h,int aa) {
        h(aa);
    }
    //返回值是委托类型
    public static Test02.hehe h() {
        return hh;
    }
​
}
//使用：创建抽象类的子类
class Test01Zi : Test01 {
    public override void hehe(int a) {
        Console.WriteLine("子类实现抽象方法：：hehe");
    }
}
//定义一个抽象方法:必须写在抽象类中
abstract class Test01 {
    public abstract void hehe(int a);
}
//定义委托：写在一个正常类中
class Test02 {
    public  delegate void hehe(int a);
}
​

1.3 委托练习

​
internal class Demo12_delegatel练习
{
​
    //饲养员的工作方法：喂动物  动物运动
    static void Work(Eat e,Sport s,string food,int hour) {
        e(food);
        s(hour);
    }
    static void Main(string[] args)
    {
​
        Work(DogEat,DogSport,"骨头",1);
        //c#支持方法中定义方法：：建议不要使用：：只能被当前方法访问到
        void PigEat(string name)
        {
            Console.WriteLine("猪：：：正在进食：：" + name);
        }
        void PigSport(int h)
        {
            Console.WriteLine("猪：：：正在运动：：抓老鼠" + h);
        }
​
        Work(PigEat, PigSport, "饲料", 1);
​
    }
    static void DogEat(string name) {
        Console.WriteLine("狗：：：正在进食：："+name);
    }
    static void DogSport(int h)
    {
        Console.WriteLine("狗：：：正在运动：：洗澡" + h);
    }
    delegate void Eat(string name);
    delegate void Sport(int hour);
}

2 lambda表达式

2.1 概念

lambda表达式：：实现抽象方法/委托的一种简写方式
格式：=>

2.2 抽象类或者接口中使用lambda(了解)

internal class Demo12_lambda表达式
{
​
    static void Main(string[] args)
    {
       //注意：c#不支持  通过lambda创建抽象类的匿名子类或者接口的匿名实现类
    }
}
// 定义接口
public interface ICalculator
{
    int Calculate(int a, int b); // 抽象方法
}
//实现类中使用lambda表达式
public class Adder : ICalculator
{
    public int Calculate(int a, int b) => a + b;
    //不使用lambda：：其实没省略太多
    //public int Calculate(int a, int b) {
    //    return a + b;
    // }
}

2.3 实现委托 使用lambda表达式

 /*
  lambda表达式：：实现抽象方法/委托的一种简写方式
  格式：=>
  
  */
 internal class Demo12_lambda表达式01
 {
     //定义委托
     delegate int hehe(int a, int b);
     delegate void hehehe(int a, int b);
     static void Main(string[] args)
     {
         //定义方法来实现委托
         int hehe1(int aa,int bb) {
             return aa + bb;
         }
         Demo12_lambda表达式01.hehe  h1 = hehe1;
         int n=h1(1,2);
​
         //通过lambda实现委托
         //lambda实现抽象方法的简化写法：：匿名方法
         //(int aa, int cc)是参数列表
         //{ Console.WriteLine("aa=" + aa); return aa + cc; }是方法体
         hehe h2 = (int aa, int cc) => { 
             Console.WriteLine("aa=" + aa); 
             return aa + cc;
         };
         h2(1,2);
​
         //lambda简化1：参数列表的数据类型可以省略
         h2 = (aa, cc) => { 
               Console.WriteLine("aa=" + aa);
               return aa + cc;
         };
         //lambda简化2：如果方法体 只有一个语句 {}可以省略
         hehehe h3 = (int a, int b) => {
               Console.WriteLine(a + ":::" + b); 
         };
         h3 = (int a, int b) => Console.WriteLine(a + ":::" + b);
         //lambda简化3：如果方法体 只是return
         h2 = (aa, cc) => aa+cc;
     }
 }