Lambda 表达式 和 Predicate 泛型委托

Lambda 表达式 和 Predicate 泛型委托

2011-01-06 14:36 by 田志良, 2744 visits, 收藏, 编辑

1. Lambda表达式

　　“Lambda” 表达式”是一个匿名函数，用于创建委托或表达式树类型。

　　“=>”为Lambda 运算符，读为“goes to”。Lambda 运算符左边是“输入参数”，右边是“表达式或语句块”，如下所示：

1 delegate int del(int i);
2 static void Main(string[] args)
3 {
4     del myDelegate = x => x * x;
5     int j = myDelegate(5); //j = 25
6 }

　　使用“Lambda 表达式”请注意一下几点：

　　1）=> 运算符具有与赋值运算符 (=) 相同的优先级，并且是右结合运算符。

　　2）在 is 或 as 运算符的左侧不允许使用 Lambda。

　　3）适用于匿名方法的所有限制也适用于 Lambda 表达式，如：Lambda 语句无法用于创建表达式树。

　　4）只有在 Lambda 有一个输入参数时，括号才是可选的，否则括号是必需的，两个或更多输入参数由括在括号中的逗号分隔。

　　5）有时，编译器难于或无法推断输入类型，如果出现这种情况，显式指定类型：

1 (int x, string s) => s.Length > x

6）使用空括号指定零个输入参数：

1 () => SomeMethod()

7）Lambda 语句的主体可以包含任意数量的语句，但在实际运用中，不会多于两个或三个语句。

1 delegate void TestDelegate(string s);
2 …
3 TestDelegate myDel = n => { string s = n + " " + "World"; Console.WriteLine(s); };
4 myDel("Hello");

8）在编写 Lambda 时，通常不必为输入参数指定类型，因为编译器可以根据 Lambda 主体、基础委托类型以及 C# 语言规范中描述的其他因素推断类型。Lambda 表达式本身没有类型，但是，有时会不正式地论及 Lambda 表达式的“类型”，在这些情况下，类型是指委托类型或 Lambda 表达式所转换为的 Expression 类型。Lambda 的一般规则如下：

• Lambda 包含的参数数量必须与委托类型包含的参数数量相同。
• Lambda 中的每个输入参数必须都能够隐式转换为其对应的委托参数。
• Lambda 的返回值（如果有）必须能够隐式转换为委托的返回类型。

　　9）Lambda 可以引用“外部变量”，这些变量位于在其中定义 Lambda 的封闭方法或类型的范围内。 将会存储通过这种方法捕获的变量以供在 Lambda 表达式中使用，即使变量将以其他方式超出范围或被作为垃圾回收。 必须明确地分配外部变量，然后才能在 Lambda 表达式中使用该变量。如下例所示：

01 using System;
02
03 delegate bool D();
04 delegate bool D2(int i);
05
06 class Test
07 {
08     D del;
09     D2 del2;
10     public void TestMethod(int input)
11     {
12         int j = 0;
13
14         // del在方法体内被调用
15         del = () => { j = 10; return j > input; };
16
17         // del2在外部调用
18         del2 = (x) => { return x == j; };
19
20         // 输出: j = 0
21         Console.WriteLine("j = {0}", j);
22
23         // 调用委托
24         bool boolResult = del();
25
26         // 输出: j = 10 b = True
27         Console.WriteLine("j = {0}.b = {1}", j, boolResult);
28     }
29
30     static void Main()
31     {
32         Test test = new Test();
33         test.TestMethod(5);
34
35         // del2 仍然保存TestMethod方法的局部变量j
36         bool result = test.del2(10);
37
38         // 输出: True
39         Console.WriteLine(result);
40
41         Console.ReadKey();
42     }
43 }

10）下列规则适用于 Lambda 表达式中的变量范围：

• 捕获的变量将不会被作为垃圾回收，直至引用变量的委托超出范围为止。
• 在外部方法中看不到 Lambda 表达式内引入的变量。
• Lambda 表达式无法从封闭方法中直接捕获 ref 或 out 参数。
• Lambda 表达式中的返回语句不会导致封闭方法返回。
• Lambda 表达式不能包含其目标位于所包含匿名函数主体外部或内部的 goto 语句、break 语句或 continue 语句。

2. Predicate 泛型委托

　　“Predicate 泛型委托”表示定义一组条件并确定指定对象是否符合这些条件的方法，其本质为一委托，在该委托中定义一组条件，用以判断传入对象是否符合这些条件，如果符合，返回True，如果不符合，返回false。

　　语法：

1 public delegate bool Predicate<T> (
2     T obj
3 )

类型参数说明：

• 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 泛型委托”的拓展应用。

　　例子一：

01 public class GenericDelegateDemo
02 {
03     List<String> listString = new List<String>()
04     {
05         "One","Two","Three","Four","Fice","Six","Seven","Eight","Nine","Ten"
06     };
07
08     String[] arrayString = new String[]
09     {
10          "One","Two","Three","Four","Fice","Six","Seven","Eight","Nine","Ten"
11     };
12
13     public String[] GetFirstStringFromArray()
14     {
15         return Array.FindAll(arrayString, (c) => { return c.Length <= 3; });
16     }
17
18     public List<String> GetFirstStringFromList()
19     {
20         return listString.FindAll((c) => { return c.Length <= 3; });
21     }
22
23     public String[] GetFirstStringFromArray_1()
24     {
25         return Array.FindAll(arrayString, GetString);
26     }
27
28     public List<String> GetFirstStringFromList_1()
29     {
30         return listString.FindAll(GetString);
31     }
32
33     private bool GetString(String str)
34     {
35         if (str.Length <= 3)
36             return true;
37         else
38             return false;
39     }
40 }

　　例子二：

view source print ?

01	public class GenericDelegateDemo

02

{

03	List<String> listString = new List<String>() { "One", "Two", "Three", "Four", "Fice", "Six", "Seven", "Eight", "Nine", "Ten" };

04

05	public String GetStringList(Predicate<String> p)

06

{

07	foreach (string item in listString)

08

{

09	if (p(item))

10	return item;

11

}

12	return null;

13

}

14

15	public bool ExistString()

16

{

17	string str = GetStringList(a => { return a.Length <= 3 && a.Contains('S'); });

18	if (str == null)

19	return false;

20

else

21	return true;

22

}

23

}

远程应用程序域通信 MarshalByRefObject

2011-01-07 13:49 by 田志良, 412 visits, 收藏, 编辑

1. 应用程序域简介

　　应用程序域是一个操作系统进程中一个或多个应用程序所驻留的分区。同一应用程序域中的对象直接通信。不同应用程序域中的对象的通信方式有两种：一种是跨应用程序域边界传输对象副本，一种是使用代理交换消息。MarshalByRefObject 就是通过使用代理交换消息来跨应用程序域边界进行通信的对象的基类。

2. MarshalByRefObject 跨应用程序域通信

　　MarshalByRefObject 对象在本地应用程序域的边界内可直接访问。远程应用程序域中的应用程序首次访问 MarshalByRefObject 时，会向该远程应用程序传递代理。对该代理后面的调用将封送回驻留在本地应用程序域中的对象。当跨应用程序域边界使用类型时，类型必须是从 MarshalByRefObject 继承的，而且由于对象的成员在创建它们的应用程序域之外无法使用，所以不得复制对象的状态。

　　MarshalByRefObject 通过ObjRef封送对象，封送的行为是由真实代理（RemotingProxy）完成。当MarshalByRefObject 通过透明代理传递远程对象时，透明代理将把基于堆栈的方法调用转换为方法调用消息（IMethodCallMessage），转发给真实代理。真实代理封送对象，将方法调用消息转发给远程应用程序域。远程应用程序域监听到方法调用消息后，取出封送好的ObjRef，将其解封（unmarshal）为本地的对象，并获得透明代理，然后将方法调用消息转换为基于堆栈的方法调用对象。

　　对象是在本地维护的，但是方法可以在远程调用。比如：本地浏览器远程访问一个Web应用程序，浏览器只是发送一个个的请求，Web应用程序提供服务，并返回处理结果。Web应用程序的状态、数据等信息与浏览器没有直接关联。在Remoting中也一样，当本地应用程序获得一个远程对象时，实际上只获得对这个对象的远程引用，虽然可以调用它的方法，但实际上这些操作都是在远程应用程序中完成，即：对象本身并没有被往返传递，传递的 只是传入传出的参数。

3. MarshalByRefObject 示例

01 using System;
02 using System.Runtime.Remoting;
03 using System.Security.Permissions;
04
05 public class SetObjectUriForMarshalTest  {
06
07     class TestClass : MarshalByRefObject {
08     }
09
10     [SecurityPermission(SecurityAction.LinkDemand)]
11     public static void Main()  {
12
13         TestClass obj = new TestClass();
14
15         RemotingServices.SetObjectUriForMarshal(obj, "testUri");
16         RemotingServices.Marshal(obj);
17
18         Console.WriteLine(RemotingServices.GetObjectUri(obj));
19     }
20 }