.NET中委托与lambda表达式的使用

委托

是一种数据类型，是用来存放方法的。

为什么要使用委托？

例：现在运用控制台输出list数据中年龄大于或小于21的姓名，下面为一般写法。

class Program
{
 		public class Person
        {
            public string Name { get; set; }
            public int Age { get; set; }
        }
		static void Main(string[] args)
        {	//创建数据对象
            List<Person> list = new List<Person>() {
                new Person(){ Name="张三",Age=20},
                new Person(){ Name="李四",Age=21},
                new Person(){ Name="小明",Age=22},
                new Person(){ Name="小红",Age=23},
            };
            List<Person> person = FilterByAge(list,true,21);
            foreach (var item in person)
            {
                Console.WriteLine(item.Name);//输出
            }
            Console.ReadLine();
            Filter(list, p => p.Name.Contains("a"));
        }
        static List<Person> FilterByAge(List<Person> list,bool opreate,int age)//具体方法实现
        {
        	List<Person> newList=new List<Person>();
        	foreach(var item in list)
        	{
        		if(opreate)
        		{
        			if(item.Age>age)
        			{
        				newList.Add(item);
        			}
        		}
        		else
        		{
        			if(item.Age<age)
        			{
        				newList.Add(item);
        			}
        		}
        	}
        	return newList;
        }
}

由此可见，上面的方法判断较多且代码可读性较差，下面我们来运用委托实现。

class Program
{
	public delegate bool FilterPerson(Person p);//新建一个委托，相当于定义了一个方法的模板
	public class Person
        {
            public string Name { get; set; }
            public int Age { get; set; }
        }
	stattic bool FilterByAge(Person p)
	{
		if(p.Age>21)
		{
			if(p.Age>21)
			{
				return true;
			}
			return false
		}
	}
	static void Main(string[] args)
        {	//创建数据对象
            List<Person> list = new List<Person>() {
                new Person(){ Name="张三",Age=20},
                new Person(){ Name="李四",Age=21},
                new Person(){ Name="小明",Age=22},
                new Person(){ Name="小红",Age=23},
            };
            FilterPerson filter=new FilterPerson(FilterByAge);
            List<Person> person=Filter(list,filter);
            foreach (var item in person)
            {
                Console.WriteLine(item.Name);//输出
            }
            Console.ReadLine();
        }
        static List<Person> Filter(List<Person> list,FilterPerson fliter)//具体方法实现
        {
        	List<Person> newList=new List<Person>();
        	foreach(var item in list)
        	{
        		if(filiter(item))
        		{
        			newList.Add(item);
        		}
        	}
        	return newList;
        }
}

上面的代码的写法还是能够继续简化，下面我们用到了lambda表达式来简化代码：

class Program
    {
        public delegate bool FilterPerson(Person p);
         public class Person
        {
            public string Name { get; set; }
            public int Age { get; set; }
        }
        static void Main(string[] args)
        {
            List<Person> list = new List<Person>() {
                new Person(){ Name="张三",Age=20},
                new Person(){ Name="李四",Age=21},
                new Person(){ Name="小明",Age=22},
                new Person(){ Name="小红",Age=23},
            };
            List<Person> person= Filter(list, p => p.Age>21);//lambda 语法,格式："()=>{}"
            foreach (var item in person)
            {
                Console.WriteLine(item.Name);
            }
            Console.ReadLine();
        }
        static List<Person> Filter(List<Person> list,FilterPerson filter)
        {
            List<Person> newList = new List<Person>();
            foreach (var item in list)
            {
                if (filter(item))
                {
                    newList.Add(item);
                }
            }
            return newList;
        }
       

    }

lambda 语法：用来简化声明方法，多个参数时用逗号隔开，当只有一个参数时，大括号可以省略掉，方法体只有一行代码，叫lambda 表达式，大括号可以省略掉，自动将表达式的结果返回。

泛型委托

随着业务需求的增多，数据类型也会变得更加多样化，那将意味着需要定义多个委托，这就又造成了代码的重复，这时候我们便用到了泛型委托。

public delegate T AddDelegate<T>(T a,T b);

但是系统早已为我们准备好了三种类型的委托：
（1）Action（）没有参数，没有返回值。
（2）Action<>,最多传16个参数，没有返回值。
（3）Func<>,最后一个类型是返回类型，其余都是输入类型。
所以说委托一般是不需要我们定义的，系统所提供的三种委托基本可以适应大多数使用场景。