引言

 　　经过前面专题的介绍,大家应该对C# 1和C# 2中的特性有了进一步的理解了吧,现在终于迎来我们期待已久的C# 3中特性，C# 中Lambda表达式和Linq的提出相当于彻底改变我们之前的编码风格了，刚开始接触它们，一些初学者肯定会觉得很难理解，但是我相信，只要多多研究下并且弄明白之后你肯定会爱上C# 3中的所有特性的，因为我自己就是这么过来的，在去年的这个时候，我看到Lambda表达式和Linq的时候觉得很难理解，而且觉得很奇怪的（因为之前都是用C# 3之前的特性去写代码的，虽然C# 3中的特性已经出来很久了，但是自己却写的很少，也没有怎么去研究，所以就觉得很奇怪，有一种感觉就是——怎么还可以这样写的吗？），经过这段时间对C# 语言系统的学习之后，才发现新的特性都是建立在以前特性的基础上的，只是现在编译器去帮助我们解析C# 3中提出的特性，所以对于编译器而言，用C# 3.0中的特性编写的代码和C# 2.0中编写的代码是一样的。从这个专题开始，将会为大家介绍C# 3 中的特性，本专题就介绍下C# 3中提出来的一些基础特性，这些特性也是Lambda表达式和Linq的基础。

 一、自动实现的属性

当我们在类中定义的属性不需要一些额外的验证时,此时我们可以使用自动实现的属性使属性的定义更加简洁,对于C# 3中自动实现的属性,编译器编译时会创建一个私有的匿名的字段,该字段只能通过属性的get和set访问器进行访问。下面就看一个C#3中自动实现的属性的例子：

1. /// <summary> 
2.     /// 自定义类 
3.     /// </summary> 
4.     public class Person 
5.     { 
6.         // C# 3之前我们定义属性时，一般会像下面这样去定义 
7.         // 首先会先定义私有字段，再定义属性来对字段进行访问 
8.         //private string _name; 
9.         //public string Name 
10.         //{
     
11.         //    get { return _name; } 
12.         //    set { _name = value; } 
13.         //} 
14.  
15.         // C# 3之后有自动实现的属性之后 
16.         // 对于不需要额外验证的属性，就可以用自动实现的属性对属性的定义进行简化 
17.         // 不再需要额外定义一个私有字段了, 
18.         // 不定义私有字段并不是此时没有了私有字段，只是编译器帮我们生成一个匿名的私有字段，不需要我们在代码中写出 
19.         // 减少我们书写的代码 
20.         // 下面就是用自动实现的属性来定义的一个属性，其效果等效于上面属性的定义，不过比之前更加简洁了 
21.  
22.         /// <summary> 
23.         ///  姓名 
24.         /// </summary> 
25.         public string Name { get; set; } 
26.  
27.         /// <summary> 
28.         /// 年龄 
29.         /// </summary> 
30.         public int Age { get; private set; } 
31.  
32.         /// <summary> 
33.         ///  自定义构造函数 
34.         /// </summary> 
35.         /// <param name="name"></param> 
36.         public Person(string name) 
37.         { 
38.             Name = name; 
39.         } 
40.     } 

 有些人会问——你怎么知道编译器会帮我们生成一个匿名的私有字段的呢？对于这点当然通过反射工具来查看经过编译器编译之后的代码了，下面是用Reflector工具查看的一张截图：

如果在结构体中使用自动属性时,则所有构造函数都需要显式地调用无参构造函数this(),否则，就会出现编译时错误，因为只有显式调用无参构造函数this()，编译器才知道所有字段都被赋值了。下面是一段测试代码：

1. /// <summary> 
2.     ///  在结构体使用自动属性 
3.     /// </summary> 
4.     public struct TestPerson 
5.     { 
6.         // 自动属性 
7.         public string Name { get; set; } 
8.  
9.         // 在结构中所有构造函数都需要显示地调用无参数构造函数this()， 
10.         // 否则会出现编译错误 
11.         // 只有调用了无参数构造函数，编译器才知道所有字段都被赋值了 
12.         public TestPerson(string name) 
13.             //: this() 
14.         { 
15.             this.Name = name; 
16.         } 
17.     } 

把this()注释掉后就会出现编译时错误，如下图：

 二、隐式类型

用关键字var定义的变量则该变量就是为隐式类型，var 关键字告诉编译器根据变量的值类推断变量的类型。所以对于编译器而言，隐式类型同样也是显式的，同样具有一个显式的类型。

2.1 隐式类型的局部变量

用var 关键字来声明局部变量，下面一段演示代码：

1. static void Main(string[] args) 
2.         {  
3.             // 用var声明局部变量 
4.         var stringvariable = "learning hard"; 
5.             stringvariable = 2; 
6.          } 

 为什么说用var定义的变量对于编译器来说还是具有显式类型呢？在Visual studio中，将鼠标放在var部分的时候就可以看到编译器为变量推断的类型。并且变量仍然是静态类型，只是我们在代码中没有写出类型的名称而已，这个工作交给编译器根据变量的值去推断出变量的类型，为了证明变量时静态类型，当我们把2赋给变量stringvariable时就会出现编译时错误，然而在其他动态语言中，这样的赋值是可以编译通过，所以用var声明的变量仍然还是静态类型，只是我们在代码中没有写出来而已。下面是证明上面两点的截图：

 然而使用隐式类型时有一些限制,具体限制有:

• 被声明的变量是一个局部变量,不能为字段(包括静态字段和实例字段)
• 变量在声明时必须被初始化(因为编译器要根据变量的赋值来推断变量的类型，如果没有被初始化则编译器就无法推断出变量类型了， 然而C#是静态语言则必须在定义变量时指定变量的类型，所以此时变量不知道什么类型，就会出现编译时错误)
• 变量的初始化不能初始化为一个方法组，也不能为一个匿名函数（前提是不进行强制类型转化的匿名函数）
• 变量不能初始化为null(因为null可以隐式转化为任何引用类型或可空类型，所以编译器不能推断出该变量到底应该为什么类型)
• 不能用一个正在声明的变量来初始化隐式类型 (如不能这样来声明隐式类型
  // 不能用一个未赋值的变量来初始化隐私类型   // 如果变量s被初始化了就可以了   string s;    var stringvariable = s;

  )

• 不能用var来声明方法中的参数类型

 同时使用隐式类型有优点也有缺点,下面的一段示例代码完全诠释了:

1. // 隐式类型的优点 
2.             // 对于复杂类型，减少打字量 
3.             // 使用隐式类型，此时就不需要再赋值的左右两侧都指定Dictionary<string,string> 
4.             var dictionary = new Dictionary<string, string>(); 
5.           
6.             // 在foreach中使用隐式类型 
7.             foreach (var item in dictionary) 
8.             { 
9.                 //  
10.             } 
11.  
12.             // 隐式类型的缺点 
13.             // 下面代码使用隐式类型就会使得开发人员很难知道变量的具体类型 
14.             // 所以对于什么情况下使用隐式类型，完全取决个人情况，自己感觉是否使用了隐式类型会使代码看起来更整洁和容易理解 
15.             var a = 2147483649; 
16.             var b = 928888888888; 
17.             var c = 2147483644; 
18.             Console.WriteLine( "变量a的类型为：{0}",a.GetType()); 
19.             Console.WriteLine("变量b的类型为：{0}", b.GetType()); 
20.             Console.WriteLine("变量c的类型为：{0}", c.GetType()); 
21.             Console.Read(); 

 2.2 隐式类型的数组 

var不仅可以创建隐式类型的局部变量,还可以创建数组,下面是一段演示代码:

1. // 隐式类型数组演示 
2. // 编译器推断为int[]类型 
3. var intarray = new[] { 1,2,3,4}; 
4.  
5.    // 编译器推断为string[] 类型 
6.    var stringarray = new[] { "hello", "learning hard" }; 
7.  
8.    // 隐式类型数组出错的情况 
9.    var errorarray = new[] { "hello", 3 }; 

 使用隐式类型的数组时,编译器必须推断出使用什么类型的数组,编译器首先会构造一个包含大括号里面的所有表达式(如上面代码中的 1,2,3,4和"hello","learning hard")的编译时类型的集合,在这个集合中如果所有类型都能隐式转换为卫衣的一种类型，则该类型就成为数组的类型，否则，就会出现编译时错误，如代码中隐式类型数组出错的情况， 因为"hello"转化为string,而3却转化为int,此时编译器就不能确定数组的类型到底为什么,所以就会出现编译错误,错误信息为:"找不到隐式类型数组的最佳类型"

 三、对象集合初始化

3.1  对象初始化

 有了对象初始化特性之后,我们就不需要考虑定义参数不同的构造函数来应付不同情况的初始化了,就减少了在我们实体类中定义的构造函数代码,这样使代码更加简洁,下面就具体看下C# 3中的对象初始化的使用和注意事项:

1. namespace 对象集合初始化器Demo 
2. { 
3.     class Program 
4.     { 
5.         static void Main(string[] args) 
6.         { 
7.             #region 对象初始化演示 
8.             // 在C# 3.0之前，我们可能会使用下面方式来初始化对象 
9.             Person person1 = new Person(); 
10.             person1.Name = "learning hard"; 
11.             person1.Age = 25; 
12.  
13.             Person person2 = new Person("learning hard"); 
14.             person2.Age = 25; 
15.   
16.             // 如果类没有无参的构造函数就会出现编译时错误 
17.             // 因为下面的语句是调用无参构造函数来对类中的字段进行初始化的 
18.             // 大括号部分就是对象初始化程序 
19.             Person person3 = new Person { Name = "learning hard", Age = 25 }; 
20.  
21.             // 下面代码和上面代码是等价的，只不过上面省略了构造函数的圆括号而已 
22.             Person person4 = new Person() { Name = "learning hard", Age = 25 }; 
23.  
24.             Person person5 = new Person("learning hard") { Age = 25 }; 
25.  
26.             #endregion  
27.  
28.          } 
29.     } 
30.  
31.     /// <summary> 
32.     /// 自定义类 
33.     /// </summary> 
34.     public class Person 
35.     { 
36.         /// <summary> 
37.         ///  姓名 
38.         /// </summary> 
39.         public string Name { get; set; } 
40.  
41.         /// <summary> 
42.         /// 年龄 
43.         /// </summary> 
44.         public int Age { get; set; } 
45.  
46.         /// <summary> 
47.         ///  定义无参的构造函数 
48.         ///  如果类中自定义了带参数的构造函数,则编译不会生成默认的构造函数 
49.         ///  如果没有默认的构造函数,则使用对象初始化时就会报错说没有实现无参的构造函数 
50.         /// </summary> 
51.         public Person() 
52.         { 
53.         } 
54.  
55.         /// <summary> 
56.         ///  自定义构造函数 
57.         /// </summary> 
58.         /// <param name="name"></param> 
59.         public Person(string name) 
60.         { 
61.             Name = name; 
62.         } 
63.     } 
64. } 

上面代码中我用红色标注出使用对象初始化时需要注意的地方,大家也可以通过反射工具查看编译器是如何去解析对象初始化代码的。

 3.2  集合初始化

C# 3中还提出了集合初始化特性来对集合初始化进行了优化,下面是一段集合初始化的使用演示代码:

1. namespace 对象集合初始化器Demo 
2. { 
3.     class Program 
4.     { 
5.         static void Main(string[] args) 
6.         { 
7.            
8.             #region 集合初始化演示 
9.  
10.             // C# 3.0之前初始化集合使用的代码 
11.             List<string> names = new List<string>(); 
12.             names.Add("learning hard1"); 
13.             names.Add("learning hard2"); 
14.             names.Add("learning hard3"); 
15.  
16.             // 有了C# 3.0中集合初始化特性之后，就可以简化代码 
17.             // 同时下面也使用了隐式类型（使用了var关键字） 
18.             var newnames = new List<string> 
19.             { 
20.                 "learning hard1","learning hard2", "learning hard3" 
21.             }; 
22.             #endregion  
23.         } 
24.     } 
25.  
26.     /// <summary> 
27.     /// 自定义类 
28.     /// </summary> 
29.     public class Person 
30.     { 
31.         /// <summary> 
32.         ///  姓名 
33.         /// </summary> 
34.         public string Name { get; set; } 
35.  
36.         /// <summary> 
37.         /// 年龄 
38.         /// </summary> 
39.         public int Age { get; set; } 
40.  
41.         /// <summary> 
42.         ///  定义无参的构造函数 
43.         ///  如果类中自定义了带参数的构造函数,则编译不会生成默认的构造函数 
44.         ///  如果没有默认的构造函数,则使用对象初始化时就会报错说没有实现无参的构造函数 
45.         /// </summary> 
46.         public Person() 
47.         { 
48.         } 
49.         /// <summary> 
50.         ///  自定义构造函数 
51.         /// </summary> 
52.         /// <param name="name"></param> 
53.         public Person(string name) 
54.         { 
55.             Name = name; 
56.         } 
57.     } 
58. } 

集合初始化同样是编译器自动帮我们调用List的无参构造函数,然后调用Add()方法一个一个地添加进去，对于编译器而言，C# 3中使用集合初始化的代码和C#3之前写的代码是一样.然而对于开发人员来说,有了C#3的集合初始化之后,这个过程就不需要我们自己去编码,而是交给编译器帮我们做就好了, 为了证明编译器帮我们所做得事情,下面看看用反射工具来查看编译器到底是怎样帮我们来翻译集合初始化的:

1. List<string> names = new List<string>(); 
2. names.Add("learning hard1"); 
3. names.Add("learning hard2"); 
4. names.Add("learning hard3"); 
5. List<string> <>g__initLocal3 = new List<string>(); 
6. <>g__initLocal3.Add("learning hard1"); 
7. <>g__initLocal3.Add("learning hard2"); 
8. <>g__initLocal3.Add("learning hard3"); 
9. List<string> newnames = <>g__initLocal3; 

 从上面反射出来的代码可以看出，编译器确实是一位大好人，帮我们做了那么多的事情。

可能大家会有这样的疑问——对象集合初始化只不过是一个语法糖而已，就是简单地让我们少写点代码而已啊,也没有其他什么用啊?下面部分的介绍将会解决你们的疑问。

四、匿名类型

 看到匿名类型可能大家会联想到前面介绍的匿名方法,编译器对匿名类型和匿名方法都采用同样的处理方式,该方式为编译器为匿名类型生成类型名,我们在代码中不需要显式自定义一个类型,下面就看看匿名类型的使用:

1. namespace 匿名类型Demo 
2. { 
3.     class Program 
4.     { 
5.         static void Main(string[] args) 
6.         { 
7.             #region 匿名类型的使用Demo 
8.             // 定义匿名类型 
9.             // 因为这里不知道初始化的类型是什么，所以这里就必须使用隐式类型 
10.             // 此时隐式类型就发挥出了功不可没的作用，从而说明隐式类型的提出是为了服务于匿名类型的 
11.             // 而匿名类型的提出又是服务于Linq，一步步都是在微软团队的计划当中 
12.             Console.WriteLine("进入匿名类型使用演示："); 
13.             var person1 = new { Name = "learning hard", Age = 25 }; 
14.             Console.WriteLine("{0} 年龄为: {1}", person1.Name, person1.Age); 
15.             Console.Read(); 
16.             Console.WriteLine("按下Enter键进入匿名类型数组演示："); 
17.             Console.WriteLine(); 
18.             #endregion 
19.  
20.             #region 匿名类型数组演示 
21.             // 定义匿名类型数组 
22.             var personcollection = new[]  
23.             { 
24.                 new {Name ="Tom",Age=30}, 
25.                 new {Name ="Lily", Age=22}, 
26.                 new {Name ="Jerry",Age =32}, 
27.  
28.                 // 如果加入下面一句就会出现编译时错误 
29.                 // 因为此时编译器就不能推断出要转换为什么类型 
30.                 // new {Name ="learning hard"} 
31.             }; 
32.  
33.             int totalAge = 0; 
34.             foreach (var person in personcollection) 
35.             { 
36.                 // 下面代码证明Age属性是强类型的int类型 
37.                 totalAge += person.Age; 
38.             } 
39.  
40.             Console.WriteLine("所有人的年龄总和为： {0}", totalAge); 
41.             Console.ReadKey(); 
42.             #endregion 
43.         } 
44.     } 
45. } 

运行结果:

 上面匿名类型的演示中使用了前面几部分介绍的所有特性——隐式类型，对象集合初始化，所以对于前面说对象集合初始化也没有其他方面的用处的疑问也可以得到答案了，如果没有对象集合初始化,要写出这样的代码(指的是 var person1 = new { Name = "learning hard", Age = 25 };)还可能吗?所以前面的隐式类型和对象集合初始化另外的一个用处就是服务于匿名类型的, 然而匿名类型又是服务于Linq的，对于Linq的好处当时是多的数不胜数了， 后面专题中会为大家介绍Linq。

上面还指出虽然我们在代码中没有为匿名类型指定类型名,而编译器会为我们生成一个类型,为了证明这点我们同样反射工具Reflector查看下编译器最后为我们生成的代码到底是怎样的？截图如下:

 从上面截图中可以看出编译器确实为我们生成了一个匿名类型)<<Name>j__TPar, <Age>j__TPar>(其中代码相当于我们上面中定义的Person类),编译器为我们生成的这个类型是直接继承自System.Object的，并且是internal sealed(指的是该类型只在程序集内可见，并且不能被继承)。

五、总结

 到这里，本专题的介绍也就结束了， 本专题就介绍了C# 3中几个基础的特性——自动实现的属性、隐式类型、对象集合初始化和匿名类型，这些类型的提出都是服务于后面更复杂的特性Linq的，所以只有掌握好这些基础特性之后，才能更好更快地掌握好Linq。在后面一个专题将和大家聊下C#3中的Lambda表达式。