C#解惑部分细节

lambda表达式

左边括号里面是参数如果只要一个参数可以省略括号
多个参数不能省略左边括号
箭头指向执行的函数

()=>class.func 
()=>{}//直接参数后面带括号函数

什么是委托

当需要将一个方法当作另一个方法的参数时，对于某些语言例如C/C++等，需要用函数指针来处理。而对于C#来说，则使用委托机制。（把一个方法当作一个参数传递给另外一个方法这时这个当作参数的方法就是一个委托） 把方法当作参数在另一个方法中传递或调用

using System;
delegate void MyDelegate(string name);//委托对象的返回值和参数类型要和申明的一致

class Program

{
    static void Print(string name)

    {
        Console.WriteLine("hello," + name);

    }

    static void send(MyDelegate arwen)
    {
        arwen("arwenName");//这个函数作为参数可以在send里面直接执行
    }

    static void Main(string[] args)

    {   //创建委托实例
        MyDelegate arwen = Print;//可以理解为在初始化的时候初始化为一个函数
        arwen("arwen");//hello,arwen

        send(arwen);//把arwen对象作为参数传递给send然后调用
        //hello,arwenName

        MyDelegate weiwen = delegate (string name) { Console.WriteLine("hi," + name); }; //这就是匿名函数
        weiwen("weiwen");//hi,weiwen

        MyDelegate weiwen2 = adc => { Console.WriteLine("hi," + adc); }; //如果 lambda 表达式只有一个输入参数，则括号是可选的 lambda根据委托的参数类型来推断参数abc的参数类型
        weiwen2("weiwen2");//hi,weiwen2

        MyDelegate weiwenhp = (xxx) => { Console.WriteLine("hi," + xxx); };//lambda表达式
        weiwenhp("weiwenhp");//参数可以给你推断出来,所以参数你随便用个啥东东表示下,用xxx或者yyy这些乱七八糟的都可以.
        //hi,weiwenhp
    }

}

事件EVENT

事件可以看成是委托的封装使用事件以后没法在外部直接调用委托的方法
事件文档：
https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/events/how-to-subscribe-to-and-unsubscribe-from-events

namespace Test
{
    class Cat{
        public void sleep(){

               System.Console.WriteLine("猫在晒太阳");
           }
          public void attack(){

               System.Console.WriteLine("狗挠人");
           }
    }
       class Dog{
           public void play(){

               System.Console.WriteLine("狗在抓耗子");
           }
           public void attack(){

               System.Console.WriteLine("狗咬人");
           }

    }
       class Person{
           public void sleep(){
               System.Console.WriteLine("人在睡觉");
           }
              public void awake(){
               System.Console.WriteLine("人被惊醒");
           }
        
    }
delegate void Alarm();
    class home{

        Person p;
        Cat c;
        Dog d;
        public home(Person p,Cat c,Dog d)
        {
            this.p = p;
            this.c = c;
            this.d = d;
        }

        internal Dog D { get => d; set => d = value; }
        internal Cat C { get => c; set => c = value; }
        internal Person P { get => p; set => p = value; }
     
      public  Alarm alarm;//这是一个委托实例home.alarm();会直接使用
      //如果写成这样 public event Alarm alarm;//这是一个事件home.alarm();报错
        public void Alive(string str){
            if(str=="平静生活"){
            
                   d.play();
                   p.sleep();
                   c.sleep();
            }else{

                if(alarm!=null)
                {
   
                   alarm();
                   }
            }

          }
    }

    class Program{

     static void Main(string[] args)
     {
         Person p=new Person();
         
         Cat c=new Cat();
         Dog d=new Dog();
         home home=new home(p,c,d);
         home.alarm+=c.attack;
         home.alarm+=d.attack;
         home.alarm+=p.awake;
         home.Alive("平静生活");
         home.Alive("进小偷了");

        // home.alarm();//在外部可以直接调用委托来触发这些方法
         //使用事件可以封装委托
         
     }


    }
} 

namespace EventTest{
    class test{
delegate void Notify(bool pass);
    interface NotifyPass{
        event Notify notify;
    }
     class RGYLight{

      public event Notify notify;
      bool  pass;
      public void wait(){

        for (int i = 5; i >=0 ; i--)
        {
            Thread.Sleep(1000);
            System.Console.WriteLine(i);
           
        }
        pass=!pass;
        notify(pass);
        wait();
      }


 public static void Main(string[] args)
     {
         RGYLight lrgy=new RGYLight();
         buss bus=new buss();
         lrgy.notify+=bus.bussRun;
         lrgy.notify+=CarRun;
         lrgy.wait();
     
       

     }
  public static void CarRun(bool pass){

       System.Console.WriteLine(pass?"轿车直接通过":"停下来");
       }
    }
  }
}

class buss{

public void bussRun(bool pass){
         
         System.Console.WriteLine(pass?"公交车直接通过":"停下来");

      }
 }

方法的引用和调用

方法的引用，不能带()。带()的话是该方法的调用。

什么是闭包

闭包指的就是在匿名方法中捕捉了变量，为了更好的理解闭包的概念，首先需要理解两个概念 ——外部变量和被捕捉的外部变量，下面通过一个例子来解释这个两个概念：

class Program
    {
        // 定义闭包委托
        delegate void ClosureDelegate();

        static void Main(string[] args)
        {
            closureMethod();
            Console.Read();
        }

        // 闭包方法
        private static void closureMethod()
        {
            // outVariable和capturedVariable对于匿名方法而言都是外部变量
            // 然而outVariable是未捕获的外部变量，子所以是未捕获，是因为匿名方法中未引用该变量
            string outVariable = "外部变量";

            //  而capturedVariable是被匿名方法捕获的外部变量
            string capturedVariable = "捕获变量";
            ClosureDelegate closuredelegate = delegate
            {
                // localvariable是匿名方法中局部变量
                string localvariable = "匿名方法局部变量";

                Console.WriteLine(capturedVariable+" "+localvariable);
            };

            // 调用委托
            closuredelegate();
        }
    }