前几天的心情阴霾已经被那灿烂的阳光给消灭，在这里要谢谢那为朋友的指点。。

现在 偶也想说说Lambda 表达式。。

当C#2.0的匿名方法提出后，给开发人员直接处理委托带来了福音，

然而，匿名方法处理委托还是不够简单，遂Lambda 表达式就出现了

它的出现 使得委托的处理更显得易懂，简单

好直接看例子吧

：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("这是传统的代码，不含Lambda表达式");
            FindListDelegate();

            Console.WriteLine("这是匿名方法代码，不含Lambda表达式");
            FindListBook();

            Console.WriteLine("这是Lambda代码");
            FindBookByLambda();

            Console.WriteLine("这是Lambda多条代码块");
            FindBookByL();

            Console.WriteLine("这是Lambda多个参数");
            Book book = new Book();
            //当Lambda 表达式中的参数为空时，可以用“（）”来代替
            book.SetOuttockHandler((name, price)=> Console.WriteLine("要出售的书：{0}, 价格:{1}", name, price));
            book.OutBook("Jquery实战", 49.00);

            Console.ReadLine();
        }

        /// <summary>
        /// 这里使用了传统的代码模式，既方法要明确声明
        /// IsbookCatefory这个方法明确声明
        /// List泛型中 重载了FindAll这个方法，它可以接受一个委托作为参数，进行判断
        /// </summary>
        public static void FindListDelegate()
        {
            List<string> list = new List<string>();
            list.AddRange(new string[] { "武侠小说", "开发设计", "学习", "灵异小说" });
            Predicate<string> findPredicate = new Predicate<string>(IsBookCategory);
            List<string> bookCategory = list.FindAll(findPredicate);//List泛型中 重载了FindAll这个方法
            foreach (var str in bookCategory)
            {
                Console.WriteLine("{0}\t", str);
            }
        }
        public static bool IsBookCategory(string str)
        {
            return str.EndsWith("说") ? true : false;//endWitn()这是判断以什么字符结尾的
        }

        /// <summary>
        /// 这里则是用了匿名方法
        /// 匿名方法直接委托创建了一个代码块，无需另外创建单独方法
        /// </summary>
        static void FindListBook()
        {
            List<string> list = new List<string>();
            list.AddRange(new string[] { "武侠小说","仙侠小说","玄幻小说","编程书","文学书","图书"});
            List<string> bookCagtegory = list.FindAll(delegate(string str)
            {
                return str.EndsWith("说") ? true : false;

            }
                );

            foreach (var str in bookCagtegory)
            {
                Console.WriteLine("{0}\t", str);
            }
        }

        /// <summary>
        /// 这里则使用了Lambda表达式
        /// </summary>

        static void FindBookByLambda()
        {
            List<string> list=new List <string>();
            list.AddRange(new string[] { "武侠小说", "仙侠小说", "玄幻小说", "编程书", "文学书", "图书" });
            List<string> bookCategory = list.FindAll(str => str.EndsWith("说"));//Lambda表达式的形式，用Lambda 创建了个委托方法
            foreach (var str in bookCategory)
            {
                Console.WriteLine("{0}\t", str);
            }
        }

        /// <summary>
        /// Lambda表达式中多个执行语块的使用
        /// </summary>
        static void FindBookByL()
        {
            List<string> list = new List<string>();
            list.AddRange(new string[] { "武侠小说", "仙侠小说", "玄幻小说", "编程书", "文学书", "图书" });
            List<string> bookCateory = list.FindAll((str) =>               //处理参数要用“（）”
                {
                    Console.WriteLine("要比较的字符为\t:{0}", str);
                   return  str.EndsWith("书");
                });
            foreach (var str in bookCateory)
            {
                Console.WriteLine("{0}\t", str);
            }
        }

      /// <summary>
      /// 多个参数的Lambda 表达式
      /// </summary>

        //定义一个Book类，在类中使用委托
        class Book
        {
            //定义了一个出库的委托
            public delegate void Outstock(string name, double price);
            private Outstock outstock;

            public void SetOuttockHandler(Outstock target)
            {
                outstock = target;
            }

            //定义一个出库方法
            public void OutBook(string name, double price)
            {
                if (outstock != null)
                {
                    outstock.Invoke(name, price);
                }
            }

        }

    }
}

在这个例子里，我详细写出了 传统代码模式的委托使用，匿名方法下的委托使用和Lambda表达式下的委托使用

这个例子是我在看书后的一些总结