C#语法糖之第二篇: 参数默认值和命名参数 对象初始化器与集合初始化器

　　今天继续写上一篇文章C#4.0语法糖之第二篇，在开始今天的文章以前感谢各位园友的支持，经过昨天写的文章，今天有不少园友们也提出了文章中的一些不足，再次感谢这些关心个人园友，在之后些文章的过程当中不断的完善以及自我提升，给各位园友们带来更好，更高效的文章。

废话就说到这里，下面正式进入咱们的今天的C#4.0语法糖，今天给你们分享一下参数默认值、命名参数、对象初始化器和集合初始化器。

参数默认值和命名参数：方法的可选参数是.net 4.0最新提出的新的功能,对应简单的重载可使用可选参数和命名参数混合的形式来定义方法这样就能够很高效的提供代码的运行效率。设计一个方法的参数的时，可为部分或所有参数分配默认值。调用其方法时，能够从新指定分配了默认值的参数，也可使用默认值从新指定分配默认值的参数时，能够显式地为指定参数名称赋值，隐式指定的时候，是根据方法参数的顺序，靠c#编译器的推断。    

咱们用一个现实的例子来讲明一下这个问题：比我咱们有个这样的需求，有个客户类群体，他们的年龄默认都25岁，可是有些优质客户能够放宽年龄，能够是24岁或者26等等。下面我直接贴一下传统写法的代码：

 1 public class Customer  2 
 3  {  4 
 5         //构造默认25岁年龄的客户
 6 
 7         public Customer(string CustomerId, string CustomerName)  8 
 9  { 10 
11             this.Age = 25; 12 
13             this.CustomerId = CustomerId; 14 
15             this.CustomerName = CustomerName; 16 
17  } 18 
19         //构造不默认年龄的客户
20 
21         public Customer(string CustomerId, string CustomerName,int Age) 22 
23  { 24 
25             this.Age = Age; 26 
27             this.CustomerId = CustomerId; 28 
29             this.CustomerName = CustomerName; 30 
31  } 32 
33         public string CustomerId { get; set; } 34 
35         public int Age { get; set; } 36 
37         public string CustomerName { get; set; } 38 
39     }

View Code

输出代码：

 1 //默认年龄的客户
 2 
 3             Customer customer=new Customer("01","张三");  4 
 5             Console.WriteLine("Id:"+customer.CustomerId+"名称"+customer.CustomerName+"年龄"+customer.Age);  6 
 7  Console.ReadLine();  8 
 9             //指定年龄的客户
10 
11             Customer customerEx = new Customer("01", "张三",26); 12 
13            Console.WriteLine("Id:" + customerEx.CustomerId + "名称" + customerEx.CustomerName + "年龄" + customerEx.Age); 14 
15             Console.ReadLine();

View Code

输出效果：

咱们从以上代码能够看出若是名称须要默认值时还须要编写一个重载方法，这样一来代码就愈来愈多，代码的可读性也会慢慢便复杂。

这时候咱们在把C#4.0的语法糖亮出来，呵呵。

 1 public class Customer  2 
 3  {  4 
 5         public Customer(string CustomerId, string CustomerName,int Age=25)  6 
 7  {  8 
 9             this.Age = Age; 10 
11             this.CustomerId = CustomerId; 12 
13             this.CustomerName = CustomerName; 14 
15  } 16 
17         public string CustomerId { get; set; } 18 
19         public int Age { get; set; } 20 
21         public string CustomerName { get; set; } 22 
23     }

View Code

调用代码

1  // 默认年龄的客户
2             Customer customer= new Customer( " 01 ", " 张三 ");
3             Console.WriteLine( " Id: "+customer.CustomerId+ " 名称 "+customer.CustomerName+ " 年龄 "+customer.Age);
4             Console.ReadLine();
5              // 指定年龄的客户
6             Customer customerEx =  new Customer( " 02 ",  " 张三 ", 27);
7             Console.WriteLine( " Id: " + customerEx.CustomerId +  " 名称 " + customerEx.CustomerName +  " 年龄 " + customerEx.Age);
8             Console.ReadLine();

View Code

 

输出结果

输出结果：

以上输出结果能够看出效果是同样的，可是简化了一个重载方法，代码的阅读性也加强了，这就是参数默认值的魅力支出。

可是它也有它的缺点，咱们在看看使用它是须要注意的地方：

一、能够为方法和有参属性指定默认值

二、有默认值的参数，必须定义在没有默认值的参数以后

三、默认参数必须是常量

四、ref 和 out参数不能指定默认值

对象初始化器：

咱们在写一些实体类的时候，咱们每每在写构造方法的时候思考很长时间，除了一个无参构造器外还在想须要写几个构造器呢？哪些参数是须要初始化的。如今你不再须要为这事烦恼了。语法糖为你提供了对象集合初始化器，在这里经过代码对比一些这两种写法的区别和内在的关联。

 1 Customer customer=new Customer();  2 
 3             customer.CustomerId = "001";  4 
 5             customer.CustomerName = "李四";  6 
 7             customer.Age = 25;  8 
 9             Console.WriteLine("Id:"+customer.CustomerId+"名称"+customer.CustomerName+"年龄"+customer.Age); 10 
11  Console.ReadLine(); 12 
13             //对象初始化器
14 
15             Customer customerEx = new Customer 16 
17  { 18 
19                     CustomerId = "002", 20 
21                     CustomerName = "张三", 22 
23                     Age = 24
24 
25  }; 26 
27             Console.WriteLine("Id:" + customerEx.CustomerId + "名称" + customerEx.CustomerName + "年龄" + customerEx.Age); 28 
29             Console.ReadLine();

View Code

输出结果：
输出结果：

从效果上看是都同样，可是经过对象初始化器代码比较简洁，让程序员少些不少代码。

咱们再经过反编译工具来看一下对象初始化器和传统的初始化有什么关联的地方。

编译器代码以下：

 1 private static void Main(string[] args)  2 {  3     Customer customer = new Customer {  4         CustomerId = "001",  5         CustomerName = "李四",  6         Age = 0x19
 7  };  8     Console.WriteLine(string.Concat(new object[] { "Id:", customer.CustomerId, "名称", customer.CustomerName, "年龄", customer.Age }));  9  Console.ReadLine(); 10     Customer customer2 = new Customer { 11         CustomerId = "002", 12         CustomerName = "张三", 13         Age = 0x18
14  }; 15     Console.WriteLine(string.Concat(new object[] { "Id:", customer2.CustomerId, "名称", customer2.CustomerName, "年龄", customer2.Age })); 16  Console.ReadLine(); 17 }

View Code

集合初始化器：从编译器代码中能够看出这两种代码效果是同样的对象初始化器在编译器内部调用类默认无参构造函数，因此初始化对象也必须有无参构造函数才能够，这一点跟传统的对象初始化是一致的。

经过上面的对象初始化器咱们有个大致的了解了，因此集合初始化器也很天然的出来了，从下面的代码比较一下：

 1 Customer customer = new Customer();  2 
 3             customer.CustomerId = "001";  4 
 5             customer.CustomerName = "张三";  6 
 7             customer.Age = 25;  8 
 9             Customer customer2 = new Customer(); 10 
11             customer.CustomerId = "002"; 12 
13             customer.CustomerName = "李四"; 14 
15             customer.Age = 30; 16 
17            // 传统方式
18 
19             List<Customer> list=new List<Customer>(); 20 
21  list.Add(customer); 22 
23  list.Add(customer2); 24 
25             //集合初始化
26 
27             List<Customer> listC=new List<Customer>
28 
29  { 30 
31                     new Customer{CustomerId = "001",CustomerName = "张三",Age = 25}, 32 
33                     new Customer{CustomerId = "002",CustomerName = "李四",Age = 30} 34 
35                 };

View Code

编译器编译效果以下：这些代码能够看出传统的方式比较繁琐，下面的就用几行代码实现跟传统方式同样的效果。

 1 private static void Main(string[] args)  2 
 3 {  4 
 5     Customer customer = new Customer {  6 
 7         CustomerId = "001",  8 
 9         CustomerName = "张三", 10 
11         Age = 0x19
12 
13  }; 14 
15     Customer customer2 = new Customer(); 16 
17     customer.CustomerId = "002"; 18 
19     customer.CustomerName = "李四"; 20 
21     customer.Age = 30; 22 
23     new List<Customer> { customer, customer2 }; 24 
25     List<Customer> list3 = new List<Customer>(); 26 
27     Customer item = new Customer { 28 
29         CustomerId = "001", 30 
31         CustomerName = "张三", 32 
33         Age = 0x19
34 
35  }; 36 
37  list3.Add(item); 38 
39     Customer customer4 = new Customer { 40 
41         CustomerId = "002", 42 
43         CustomerName = "李四", 44 
45         Age = 30
46 
47  }; 48 
49  list3.Add(customer4); 50 
51     List<Customer> list2 = list3; 52 
53 }

View Code

以上这些能够总结出其实语法糖不是什么新语法，只不过是把之前一些传统方式的代码交给编译器来实现，以便给程序员带来方便，让程序员代码更简单，代码结构更清晰，因此我我的比较推荐使用。其中缘由我在这里就很少讲了。

以上这些观点仅凭表明我我的想法！

源代码下载地址:http://www.yaosutu.cn/archives/550