C# 匿名方法 lambda表达式 泛型委托

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Text.RegularExpressions;  
  6.   
  7. namespace _02匿名方法  
  8. {  
  9.     class Program  
  10.     {  
  11.         static void Main(string[] args)  
  12.         {  
  13.             //string s = new string('*', 100);  
  14.             //Console.WriteLine(s);  
  15.             //Console.ReadKey();  
  16.  
  17.             #region 匿名方法 + lambda表达式  
  18.   
  19.             ////匿名方法  
  20.             ////匿名方法不能直接在类中定义，而是在给委托变量赋值的时候，需要赋值一个方法，此时可以“现做现卖”，定义一个匿名方法传递给该委托。  
  21.             ////MyDelegate md = M1;  
  22.             ////无参数，无返回值的一个匿名方法。  
  23.             //MyDelegate md = delegate()  
  24.             //{  
  25.             //    Console.WriteLine("小鸟说早早。");  
  26.             //};  
  27.             //md();  
  28.             //Console.ReadKey();  
  29.   
  30.             ////没有参数没有返回值的方法使用(lambda)λ表达式  
  31.             //MyDelegate md = () => { Console.WriteLine("lambda表达式！！"); };  
  32.             //md();  
  33.             //Console.ReadKey();  
  34.   
  35.   
  36.   
  37.   
  38.             //////有参数无返回值的匿名方法  
  39.             ////MyDelegate1 md = delegate(string msg)  
  40.             ////{  
  41.             ////    Console.WriteLine("早上好！" + msg);  
  42.             ////};  
  43.             ////md("大家好");  
  44.             ////Console.ReadKey();  
  45.             ////lambda表达式不需要传递数据类型，因为委托一经限定了数据类型。  
  46.             //MyDelegate1 md = m => { Console.WriteLine(m); };  
  47.             //md("哈喽，翻译欧克。");  
  48.             //Console.ReadKey();  
  49.   
  50.   
  51.             ////有参数，有返回值的的匿名方法  
  52.             //AddDelegate ad = delegate(int n1, int n2, int n3)  
  53.             //{  
  54.             //    return n1 + n2 + n3;  
  55.             //};  
  56.   
  57.             //int result = ad(10, 120, 15);  
  58.             //Console.WriteLine(result);  
  59.             //Console.ReadKey();  
  60.   
  61.             //AddDelegate ad = (x, y, z) => { return x + y + z; };  
  62.             //int r = ad(10, 20, 30);  
  63.             //Console.WriteLine(r);  
  64.             //Console.ReadKey();  
  65.   
  66.             //AddDelegate1 ad1 = (arr) =>  
  67.             //{  
  68.             //    for (int i = 0; i < arr.Length; i++)  
  69.             //    {  
  70.             //        Console.WriteLine(arr[i]);  
  71.             //    }  
  72.             //    return arr.Sum();  
  73.             //};  
  74.             //int x = ad1(1, 2, 3, 4, 5);  
  75.             //Console.WriteLine(x);  
  76.             //Console.ReadKey();  
  77.   
  78.             //List<int> list = new List<int>();  
  79.             #endregion  
  80.  
  81.  
  82.             #region 泛型委托  
  83.             //Action  
  84.             //Action<T>  
  85.             //Func<>  
  86.   
  87.             ////1.需要保存一个无参数，无返回值的一个方法  
  88.             //Action action1 = new Action(M1);  
  89.             //action1();  
  90.             //Console.ReadKey();  
  91.   
  92.             //2.需要保存一个有一个string类型参数，但没有返回值的方法  
  93.             //MyDelegate md = M1;  
  94.             //md();  
  95.             //Console.ReadKey();  
  96.   
  97.             //MyDelegate1 md = M1;  
  98.             //md("hello");  
  99.             //Console.ReadKey();  
  100.   
  101.             //MyGenericDelegate<string> md = M1;  
  102.             //md("aaaa");  
  103.             //Console.ReadKey();  
  104.   
  105.             ////Action委托，的非泛型版本，就是一个无参数，无返回值的委托  
  106.             ////Action的泛型版本，就是一个无返回值，但是参数可以变化的委托。  
  107.             //Action<string> a1 = m => { Console.WriteLine(m); };  
  108.             //a1("类好啊");  
  109.   
  110.             //Action<int, int> a2 = (x, y) => { Console.WriteLine(x + y); };  
  111.             //a2(100, 100);  
  112.   
  113.             ////Action<string,int,string,int,double>   
  114.             //Console.ReadKey();  
  115.   
  116.             //Func委托只有一个泛型版本的，没有非泛型版本的。  
  117.             //Func<int, int, int, int> fun = M2;  
  118.             // Func<int>  
  119.             //AddDelegate fun = M2;  
  120.             //int x;  
  121.             //int n = fun(1, 2, out x);  
  122.             //Console.WriteLine(n);  
  123.             //Console.WriteLine(x);  
  124.             //Console.ReadKey();  
  125.   
  126.             //Func<int> f = () => { return 100; };  
  127.   
  128.             //int x = f();  
  129.             //Console.WriteLine(x);  
  130.             //Console.ReadKey();  
  131.  
  132.  
  133.             #endregion  
  134.  
  135.  
  136.             #region 使用lambda表达式  
  137.   
  138.             //List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 89, 10, 11, 12, 13, 14, 15 };  
  139.   
  140.             //IEnumerable<int> ie = list.Where(x => { return x > 6; });  
  141.   
  142.             
  143.   
  144.             //foreach (var item in ie)  
  145.             //{  
  146.             //    Console.WriteLine(item);  
  147.             //}  
  148.             ////for (int i = 0; i < list.Count; i++)  
  149.             ////{  
  150.             ////    Console.WriteLine(list[i]);  
  151.             ////}  
  152.             //Console.ReadKey();  
  153.  
  154.             #endregion  
  155.   
  156.   
  157.   
  158.   
  159.   
  160.   
  161.         }  
  162.         //static bool Condition(int x)  
  163.         //{  
  164.         //    return x > 6;  
  165.         //}  
  166.   
  167.         static void M1(string msg)  
  168.         {  
  169.             Console.WriteLine(msg);  
  170.         }  
  171.   
  172.         static void M1()  
  173.         {  
  174.             Console.WriteLine("ok111");  
  175.         }  
  176.   
  177.         static int M2(int n1, int n2, out int n3)  
  178.         {  
  179.             n3 = 99;  
  180.             return n1 + n2 + n3;  
  181.         }  
  182.     }  
  183.   
  184.     public delegate int AddDelegate1(params int[] arr);  
  185.   
  186.     public delegate int AddDelegate(int n1, int n2, out int n3);  
  187.     public delegate void MyDelegate1(string msg);  
  188.     public delegate void MyDelegate();  
  189.   
  190.   
  191.   
  192.     public delegate void MyGenericDelegate<T>(T args);  
  193. }  
shashou47

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: