C# 3.0新语言特性

小鱼儿 2022-08-27 11:53 146阅读 0赞

C\# 3.0新语言特性和改进包括：  
  
\* 自动属性(Auto-Implemented Properties)  
\* 隐含类型局部变量(Local Variable Type Inference)  
\* 匿名类型(Anonymous Types)  
\* 对象与集合初始化器(Object and Collection Initializers)  
\* 扩展方法(Extension Methods)  
\* Lambda表达式和Lambda表达式树 (Lambda Expression and Lambda Expression Trees)  
  
  
1,自动属性  
编译器会自动地生成私有变量和默认的get/set 操作。你也可以分别定义get和set的“protected”等访问级别。  
public class User  
\{  
public int Id \{ get; set; \}  
public string Name \{ get; set; \}  
public int Age \{ get; set; \}  
\}  
  
  
2.隐含类型局部变量  
即当一个变量声明标识为var类型并且该范围域中没有var名称类型存在，那么这个声明就称为隐含类型局部变量。如下（等同于//后面的显式声明）  
var i = 5;//int  
var j = 23.56;//double  
var k = "C Sharp";//string  
var x;//错误  
var y = null;//错误  
var z = \{ 1, 2, 3 \};//错误  
  
3.匿名类型  
匿名类型允许定义行内类型，无须显式定义类型。常和var配合使用来声明匿名类型。  
var p1 = new \{ Id = 1, Name = "YJingLee", Age = 22 \};//属性也不需要申明  
var p2 = new \{ Id = 2, Name = "XieQing", Age = 25 \};  
p1 = p2;//p1,p2结构相同，可以互相赋值  
  
  
在这里编译器会认为p1,p2相当于：  
public class SomeType  
\{  
public int Id \{ get; set; \}  
public string Name \{ get; set; \}  
public int Age \{ get; set; \}  
\}  
  
  
可以使用"new\[\]"关键字来声明数组，加上数组的初始值列表。像这样：  
  
var intArray = new\[\] \{ 2, 3, 5, 6 \};  
var strArray = new\[\] \{ "Hello", "World" \};  
var anonymousTypeArray = new\[\]  
\{  
new \{ Name = "YJingLee", Age = 22 \},  
new \{ Name = "XieQing", Age = 25 \}  
\};  
var a = intArray\[0\];  
var b = strArray\[0\];  
var c = anonymousTypeArray\[1\].Name;  
  
4.对象与集合初始化器  
  
4.1对象初始化器由一系列成员对象组成，其对象必须初始化，用逗号间隔，使用\{\}封闭。  
User user = new User \{ Id = 1, Name = "YJingLee", Age = 22 \};  
  
又例如，我把二个人加到一个基于泛型的类型为User的List集合中：  
List<User> user = new List<User>\{  
new User\{Id=1,Name="YJingLee",Age=22\},  
new User\{Id=2,Name="XieQing",Age=25\},  
\};  
  
如果有相同名字和类型的两个对象初始化器将会产生相同的实例，可以相互赋值。例如：  
User user = new User \{ Id = 1, Name = "YJingLee", Age = 22 \};  
User user2 = new User \{ Id = 2, Name = "XieQing", Age = 25 \};  
user = user2;  
  
除了在初始化类时设置简单的属性值外，对象初始化器特性也允许我们设置更复杂的嵌套(nested)属性类型。例如我们可以在上面定义的User类型同时拥有一个属于Address类型的叫“Address”的属性：  
User user = new User  
\{  
Id = 1,  
Name = "YJingLee",  
Age = 22,  
Address = new Address  
\{  
City = "NanJing",  
Zip = 21000  
\}  
\};  
  
  
4.2集合初始化器由一系列集合对象组成，用逗号间隔，使用\{\}封闭。  
List<int> num = new List<int> \{ 0, 1, 2, 6, 7, 8, 9 \};  
  
5.扩展方法  
如何将这个IsValidEmailAddress()方法添加到现有的string类里去的呢？先定义一个静态类，再定义“IsValidEmailAddress”这个静态方法来实现。  
  
public static class Extensions//静态类  
\{  
public static bool IsValidEmailAddress(this string s)  
//静态方法和this  
\{  
Regex regex = new Regex(@"^\[/w-/.\]+@(\[/w-\]+/.)+\[/w-\]\{2,4\}$");  
return regex.IsMatch(s);  
\}  
\}  
调用：  
var email = "leeyongjing@gmail.com";  
if (email.IsValidEmailAddress())  
\{  
Response.Write("YJingLee提示:这是一个正确的邮件地址");  
\}  
  
6.Lambda表达式和Lambda表达式树  
  
6.1 Lambda表达式  
所有字符串查找包含YJingLee子字符串  
C\#2.0中的方法：  
var inString = list.FindAll(delegate(string s)  
\{ return s.Indexof("YJingLee") >= 0; \});  
  
C\#3.0中的方法：  
var inString = list.FindAll(s => s.Indexof("YJingLee") >= 0);  
Lambda表达式格式：(参数列表)=>表达式或语句块  
具体意义：定义Lambda接受参数列表，运行表达式或语句块返回表达式或语句块的值传给这个参数列表。  
  
Lambda表达式参数类型可以是隐式类型或显式类型。在显式列表中，每个参数的类型是显式指定的，在隐式列表中，参数的类型由Lambda表达式出现的语境自动推断类型。  
Lambda表达式的参数列表可以有一个或多个参数，或者无参数。在有单一的隐型参数的lambda表达式中，圆括号可以从参数列表中省略。  
例如：  
(x, y) => x \* y;//多参数，隐式类型=>表达式  
x => x \* 10;//单参数，隐式类型=>表达式  
x => \{ return x \* 10; \}; //单参数，隐式类型=>语句块  
(int x) => x \* 10;//单参数，显式类型=>表达式  
(int x) => \{ return x \* 10; \};//单参数，显式类型=>语句块  
() => Console.WriteLine(); //无参数  
  
  
6.2 Lambda表达式树  
  
Lambda表达式树允许我们像处理数据（比如读取，修改）一样来处理Lambda表达式。我以一个例子简单说明：  
  
Expression<Func<int, bool>> filter = n => (n \* 3) < 5;  
BinaryExpression lt = (BinaryExpression)filter.Body;  
BinaryExpression mult = (BinaryExpression)lt.Left;  
ParameterExpression en = (ParameterExpression)mult.Left;  
ConstantExpression three = (ConstantExpression)mult.Right;  
ConstantExpression five = (ConstantExpression)lt.Right;  
var One = filter.Compile();  
Console.WriteLine("Result: \{0\},\{1\}", One(5), One(1));  
Console.WriteLine("(\{0\} (\{1\} \{2\} \{3\}) \{4\})", lt.NodeType,  
mult.NodeType, en.Name, three.Value, five.Value);