委托，Action，Function，多播委托，匿名函数，回调函数，Lamada表达式，基于委托的同步异步，利用委托实现跨窗体传值 一文详解，适合新手！！！看不懂是我的错！！

主要是自己的学习笔记，自己比较菜更能理解菜鸟们的心情，刚接触C#不久。委托一直看大佬们的代码里尝尝用到，自己用的也是云里雾里，因此今天抽空梳理一下方便自己以后查阅，因为不用经常忘记。

public  class Program   //委托的声明也可以放在类的外面，命名空间下面 与类同级。作为全局委托
    {

        public  delegate  void  Mydelegate();//首先声明一个无返回值无输入参数的委托
        public delegate string Mydelegate2();//声明一个有返回值无输入参数的委托
        public delegate string Mydelegate3(string name );  //声明一个有返回值有输入参数的委托
        public delegate string Mydelegate4( string name,out double d ); //声明一个有返回值有输入和输出参数的委托

        public static Mydelegate del;//创建委托变量
        public static Mydelegate2 del2;//创建委托变量

        
         static   void Main(string[] args)
         {
            del = Methond;//委托的绑定，调用这个del委托变量就是调用方法签名相同的Methond这个方法。
            //del += Methond2;//多播委托，一个委托变量可以绑定很多相同方法签名的方法。
            //del += Methond3;
            //del += Methond4;
            //del -= Methond;
            //del();
            //del2 = Methond5;
            //del2();
            //double d;
            //Mydelegate4 del4 = Methond6;
            //del4("nihao ",out d);
            //Test(del);
            //string a = "nihao ";

 

//匿名函数 --------只有方法体的方法
            //指向的方法必须跟委托签名相同，因此可以省略方法签名过程
            //Mydelegate3 del3 = delegate (string name) { name = a; Console.WriteLine("匿名函数被调用{0}",a); return a;  };
            //del3(a);
            //Thread th = new Thread(delegate ()
            //{
            //    //方法实现了………………功能
            //});
            //Lambda 表达式
            //delegate(){}---------()=>{} 总结，Lambda表达式就是匿名函数，匿名函数就是委托类型的方法
            //Thread th = new Thread(() => { });
            //Mydelegate3 del3 = (string name) => { return ""; };
            //Mydelegate4 del4 = delegate (string name, out double d)
            //{
            //    d = 3 + 3.02;
            //    name = "这是一个带返回值带输入 输出参数的匿名方法";
            //    return name;

            //};
            //Mydelegate4 del5 = (string name, out double d) =>
            //{
            //    d = 3 + 3.02;
            //    name = "这是一个带返回值带输入 输出参数的匿名方法的lamada 表达式写法";
            //    return name;
            //};
            //List<int> list = new List<int> { 1, 2, 34 };
            //list.RemoveAll(delegate (int x) { return x < 30; });//可以简化成下面的内容 简化过程：当输入参数只有
            //list.RemoveAll(x=> x< 30);
            // 泛型委托 Action Func---------都只能有输入参数，不能有输出参数  out ref
            //Action ----指向没有返回值，有0到16个输入参数的方法
            //Action a = new Action(() => { Console.WriteLine("这是一个无参无返回值的泛型委托方法"); });
            //Action<int> b = new Action<int>((int n) => { Console.WriteLine("只有一个输入参数的泛型委托方法"); });
            //Action<int, double> c = new Action<int, double>((int e, double d) => { Console.WriteLine("这是一个两个输入参数的不带返回值的委托方法"); });
            //a();
            //b(3);
            //c(2, 2.56);
            //Func--------指向有返回值，有0-16个输入参数的方法
            //没有输入参数时
            //Func<int>f=new Func<int>(() => {  return 0; });   
            //有输入参数时，--------最后一个代表的事返回值的数据类型
            //Func<int, double, string, double> f = new Func<int, double, string, double>((int a, double d, string g) =>
            //{
            //    a = 3;
            //    d = 3.5;
            //    g = "";
            //    return d;
            //});

            //同异步编程------基于委托执行
            //Action b = (()=>{});
            // b();------//直接执行
            // 委托变量.Invoke()--同步执行
            // 委托变量.BeginInvoke()-------异步执行
            //Action a = new Action(() =>
            //{
            //    Console.WriteLine("委托指向匿名函数");
            //});
            //a.Invoke();
            //a.BeginInvoke(null,null);
            //同步和异步的区别
            //无参数时候 
            //Action b = new Action(() =>
            //{
            //    Console.WriteLine("委托方法被调用");
            //    Thread.Sleep(3000);

            //});
            //b.Invoke();
            //Console.WriteLine("同步运行结束");
            //b.BeginInvoke(null, null);
            //Console.WriteLine("主程序运行中");
            //Action<string> a = (string s) =>
            //{
            //    Thread.Sleep(6000);
            //    Console.WriteLine(s);   
            //};
            //a.Invoke("同步执行的结果");
            //Console.WriteLine("1主程序运行中");
            //a.BeginInvoke("异步执行的结果",null,null);
            //Console.WriteLine("2主程序运行中");

            //有参数也有返回值 
            // Func
            //Func<int, string> a = ((int c) =>
            //{
            //    c++;
            //    Thread.Sleep(3000);
            //    Console.WriteLine(c);
            //    return "";

            //});
            //double Score;
            //Mydelegate4 del4 = (string name, out double score) =>
            //{
            //    Thread.Sleep(3000);
            //    Console.WriteLine("name");
            //    score = 10.02+2;
            //    return "";
            //};
            //Console.WriteLine("主程序云心中");
            //del4.BeginInvoke("这是异步调用",out Score,null,null);
            Func<string, string> f = new Func<string, string>((string s) =>
            {
                Thread.Sleep(3000); 
                return s;

            });
            string sf = f.Invoke("123");
            Console.WriteLine(sf);
        /*    IAsyncResult ar= f.BeginInvoke("1234", Callback, f);*///获取异步执行的状态
            /*string msg=f.EndInvoke(ar);*///等到方法执行完成才能获取返回值，阻塞程序的运行
            Console.WriteLine("主程序运行中");
            //Console.WriteLine(msg); 

            //BeginInvoke(null,null)  第一个参数，回调函数：当前A方法执行完成后，又会继续执行的方法B（B就是回调函数）
            //第二个参数，------回调函数中所需要的对象
            f.BeginInvoke("异步执行，利用回调函数取得返回值", (IAsyncResult ar) =>
            {
                string msg=f.EndInvoke(ar); 
                Console.WriteLine(msg);
            },null);

            //回调函数应用场景：主程序在采集图像，我不知道你什么时候采集图像结束，采集图像结束后就去处理图像，处理图像的过程就可以封装
            //在回调函数里面，然后主程序继续运行。

            //窗体应用中的Invoke 和BeginInvoke 跟这个Invoke有点区别 委托的异步调用里面传的事参数，而控件里传的是方法。
            
            //控件.Invoke（方法）
            //BiginInvoke(方法)  并不能解决UI 界面卡顿问题

            Console.ReadKey();
         }
        
        public static void  Callback(IAsyncResult ar)
        {//从回调函数中获取返回值
            //ar.AsyncState;-----这个属性可以获取传递过来的对象
            //只不过获取的对象是object类型，所以需要转换
            //Func<string,string >f=ar.AsyncState as Func<string,string>;
            Func<string, string> f = (Func<string, string>)ar.AsyncState;//也可以用强制类型转换
           string  msg = f.EndInvoke(ar);
        }
        public static void Test (Mydelegate del)
        {
            Console.WriteLine("调用委托方法.将另外个方法作为参数传了进来");
        }

        public static void Methond()
        {
            Console.WriteLine("this is a Methond without return");
        }
        static  void Methond2()
        {
            Console.WriteLine("这是方法2");    
        }
        static void Methond3()
        {
            Console.WriteLine("这是方法3");
        }
        static void Methond4()
        {
            Console.WriteLine("这是方法4");
        }

        public static string Methond5()
        {
            Console.WriteLine("这是一个带返回值的方法");
            return "方法5执行成功";
        }
        public static string Methond6(string name ,out double d)
        {
            name = "委托测试";
            d = 10.34;
            Console.WriteLine("这是一个有返回值有输入输出参数的方法");
            return name;
        }
    }
}