代码改变世界

Lambda 表达式 和 Predicate 泛型委托

2011-01-06 14:36  田志良  阅读(...)  评论(...编辑  收藏
1. Lambda表达式
  “Lambda” 表达式”是一个匿名函数,用于创建委托或表达式树类型。
  “=>”为Lambda 运算符,读为“goes to”。Lambda 运算符左边是“输入参数”,右边是“表达式或语句块”,如下所示:
delegate int del(int i);
static void Main(string[] args)
{
    del myDelegate = x => x * x;
    int j = myDelegate(5); //j = 25
}
  使用“Lambda 表达式”请注意一下几点:
  1)=> 运算符具有与赋值运算符 (=) 相同的优先级,并且是右结合运算符。
  2)在 is 或 as 运算符的左侧不允许使用 Lambda。
  3)适用于匿名方法的所有限制也适用于 Lambda 表达式,如:Lambda 语句无法用于创建表达式树。
  4)只有在 Lambda 有一个输入参数时,括号才是可选的,否则括号是必需的,两个或更多输入参数由括在括号中的逗号分隔。
  5)有时,编译器难于或无法推断输入类型,如果出现这种情况,显式指定类型:
(int x, string s) => s.Length > x
6)使用空括号指定零个输入参数:
() => SomeMethod()
7)Lambda 语句的主体可以包含任意数量的语句,但在实际运用中,不会多于两个或三个语句。
delegate void TestDelegate(string s);
…
TestDelegate myDel = n => { string s = n + " " + "World"; Console.WriteLine(s); };
myDel("Hello");
8)在编写 Lambda 时,通常不必为输入参数指定类型,因为编译器可以根据 Lambda 主体、基础委托类型以及 C# 语言规范中描述的其他因素推断类型。Lambda 表达式本身没有类型,但是,有时会不正式地论及 Lambda 表达式的“类型”,在这些情况下,类型是指委托类型或 Lambda 表达式所转换为的 Expression 类型。Lambda 的一般规则如下:
  • Lambda 包含的参数数量必须与委托类型包含的参数数量相同。
  • Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。
  • Lambda 的返回值(如果有)必须能够隐式转换为委托的返回类型。
  9)Lambda 可以引用“外部变量”,这些变量位于在其中定义 Lambda 的封闭方法或类型的范围内。 将会存储通过这种方法捕获的变量以供在 Lambda 表达式中使用,即使变量将以其他方式超出范围或被作为垃圾回收。 必须明确地分配外部变量,然后才能在 Lambda 表达式中使用该变量。如下例所示:
using System;

delegate bool D();
delegate bool D2(int i);

class Test
{
    D del;
    D2 del2;
    public void TestMethod(int input)
    {
        int j = 0;

        // del在方法体内被调用
        del = () => { j = 10; return j > input; };

        // del2在外部调用
        del2 = (x) => { return x == j; };

        // 输出: j = 0 
        Console.WriteLine("j = {0}", j);

        // 调用委托
        bool boolResult = del();

        // 输出: j = 10 b = True
        Console.WriteLine("j = {0}.b = {1}", j, boolResult);
    }

    static void Main()
    {
        Test test = new Test();
        test.TestMethod(5);

        // del2 仍然保存TestMethod方法的局部变量j
        bool result = test.del2(10);

        // 输出: True
        Console.WriteLine(result);

        Console.ReadKey();
    }
}
10)下列规则适用于 Lambda 表达式中的变量范围:
  • 捕获的变量将不会被作为垃圾回收,直至引用变量的委托超出范围为止。
  • 在外部方法中看不到 Lambda 表达式内引入的变量。
  • Lambda 表达式无法从封闭方法中直接捕获 ref 或 out 参数。
  • Lambda 表达式中的返回语句不会导致封闭方法返回。
  • Lambda 表达式不能包含其目标位于所包含匿名函数主体外部或内部的 goto 语句、break 语句或 continue 语句。
2. Predicate 泛型委托
  “Predicate 泛型委托”表示定义一组条件并确定指定对象是否符合这些条件的方法,其本质为一委托,在该委托中定义一组条件,用以判断传入对象是否符合这些条件,如果符合,返回True,如果不符合,返回false。
  语法:
public delegate bool Predicate<T> (
	T obj
)
类型参数说明:
  • T:要比较的对象的类型。
  • obj:要按照由此委托表示的方法中定义的条件进行比较的对象。
  • 返回值:如果 obj 符合由此委托表示的方法中定义的条件,则为 true;否则为 false。
  此委托由 Array 和 List 类的几种方法使用,用于在集合中搜索元素:
  Array : public T[] FindAll<T>(T[] array, Predicate<T> match);
  List:public List<T> FindAll(Predicate<T> match);
  下面给出两个例子,第一个例子演示“Predicate 泛型委托”在Array、List集合中的应用,第二个例子演示“Predicate 泛型委托”的拓展应用。
  例子一:
    public class GenericDelegateDemo
    {
        List<String> listString = new List<String>()
        {
            "One","Two","Three","Four","Fice","Six","Seven","Eight","Nine","Ten"
        };

        String[] arrayString = new String[] 
        {
             "One","Two","Three","Four","Fice","Six","Seven","Eight","Nine","Ten"
        };

        public String[] GetFirstStringFromArray()
        {
            return Array.FindAll(arrayString, (c) => { return c.Length <= 3; });
        }

        public List<String> GetFirstStringFromList()
        {
            return listString.FindAll((c) => { return c.Length <= 3; });
        }

        public String[] GetFirstStringFromArray_1()
        {
            return Array.FindAll(arrayString, GetString);
        }

        public List<String> GetFirstStringFromList_1()
        {
            return listString.FindAll(GetString);
        }

        private bool GetString(String str)
        {
            if (str.Length <= 3)
                return true;
            else
                return false;
        }
    }
  例子二:
    public class GenericDelegateDemo
    {
        List<String> listString = new List<String>() { "One", "Two", "Three", "Four", "Fice", "Six", "Seven", "Eight", "Nine", "Ten" };
        
        public String GetStringList(Predicate<String> p)
        {
            foreach (string item in listString)
            {
                if (p(item))
                    return item;
            }
            return null;
        }

        public bool ExistString()
        {
            string str = GetStringList(a => { return a.Length <= 3 && a.Contains('S'); });
            if (str == null)
                return false;
            else
                return true;
        }
    }