C#学习笔记（七）：智能编译器

自动实现属性

C#提供的set/get可以让我们很方便的使用属性，但是某些情况下书写还是稍微麻烦了点，如下：

 public class Test
 {
     private string _name;

     public string name
     {
         set { _name = value; }
         get { return _name; }
     }
 }

这种情况我们可以如下进行简写：

 public class Test
 {
     public string name { set; get; }
 }

当然，实际上我们在编译的时候，编译器会自动帮我们生成类似于没有简化的代码的样子。

隐式类型

我们如果在声明变量时想偷偷懒的话，可以使用隐式类型关键字var，如下：

string str1 = "hello";
var str2 = "world";
var str3 = str1;
var str4 = str2;

上面的4个变量都是string类型的，而使用var定义的话，则把类型交给编译器，编译器会根据我们赋予的值确定变量的类型，最后编译时编译器会编译为如下的代码：

string str1 = "hello";
string str2 = "world";
string str3 = str1;
string str4 = str2;

我们看看隐式类型需要注意的地方：

1. 声明的变量必须是局部变量，不能为静态字段或实例字段；
2. 变量声明时必须进行初始化；
3. 变量不能初始化为方法组或匿名函数；
4. 变量不能初始化为null；
5. 不能用var来声明方法中的参数；
6. 不能使用没有赋值的变量赋值给var，如下是错误的：

string str1;
var str2 = str1;

隐式类型数组

隐式类型同样可以用在数组上：

var a1 = new[] { , ,  };
var a2 = new[] { "a", "b", "c" };

初始化器

初始化器可以在实例化一个对象时直接设置其内部public属性的值，可以避免手动编写大量的构造函数，如下：

 using System;

 namespace Study
 {
     class Program
     {
         static void Main(string[] args)
         {
             //普通初始化
             Test t1 = new Test();
             Console.WriteLine(t1);
             Test t2 = new Test();
             Console.WriteLine(t2);

             //使用初始化器初始化
             Test t3 = new Test { a = , b = 2.5f };
             Console.WriteLine(t3);
             Test t4 = new Test() { b = 1.111f };
             Console.WriteLine(t4);

             Console.Read();
         }
     }

     public class Test
     {
         public int a;

         public float b;

         public Test()
         {
         }

         public Test(int a)
         {
             this.a = a;
         }

         public override string ToString()
         {
             return "a: " + a + ", b: " + b;
         }
     }
 }

结果如下：

 a: , b:
 a: , b:
 a: , b: 2.5
 a: , b: 1.111

集合的初始化器

当我们创建集合的时候，就可以使用初始化器向集合中添加已经设定好值的对象了，方便快捷：

 using System;
 using System.Collections.Generic;

 namespace Study
 {
     class Program
     {
         static void Main(string[] args)
         {
             //列表
             List<Test> list = new List<Test>
             {
                 new Test(),
                 new Test{a = , b = 0.1f},
                 new Test(){b = 200.5f},
                 null,
             };

             //哈希表
             Dictionary<int, Test> map = new Dictionary<int, Test>
             {
                 {, new Test()},
                 {, new Test{a = , b = 0.1f}},
                 {, new Test(){b = 200.5f}},
                 {, null},
             };

             Console.Read();
         }
     }

     public class Test
     {
         public int a;

         public float b;

         public Test()
         {
         }

         public Test(int a)
         {
             this.a = a;
         }

         public override string ToString()
         {
             return "a: " + a + ", b: " + b;
         }
     }
 }

匿名类

另外初始化器还可以生成匿名类，但是需要注意的是匿名类中的属性是只读的：

 using System;

 namespace Study
 {
     class Program
     {
         static void Main(string[] args)
         {
             var person = new {name = "Alen", age = };
             //这是不允许的
             //person.age = 20;
             Console.WriteLine(person.age);

             Console.Read();
         }
     }
 }

可选参数

在C#4.0之前我们对方法参数设置默认值时一般使用重载，一般是这么写的：

 public void Func(int a, int b)
 {
     //...
 }

 public void Func(int a)
 {
     Func(a, );
 }

如果使用可选参数则会更加方便：

 public void Func(int a, int b = )
 {
     //...
 }

可选参数需要注意的地方：

1. 可选参数必须位于必选参数之后；
2. 可选参数的默认值必须是常量，如数字、常量字符串、null、const成员和枚举成员等。
3. params修饰的参数数组不能为可选参数；
4. ref或out引用传递的参数不能为可选参数；

命名实参

一般配合可选参数使用，我们具体来看一个例子：

 public static void Func(int a, int b = , bool c = true, string d = "center", int e = )
 {
     //...
 }

如果只需要设置参数a和e，其它参数均保持默认值，一般的写法如下：

Func(, , true, "center", );

试想一下，如果默认参数特别多但是我们只需要设定最后一个参数时，是不是感觉要写死，不用担心，C#引入的命名实参可以帮我们解决这个问题，我们只需要这么编写即可：

//只为可选参数指定命名实参
Func(, e : );
//为所有参数指定命名实参
Func(a : , e : );