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[] { 0, 1, 2 };
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(10);
            Console.WriteLine(t2);

            //使用初始化器初始化
            Test t3 = new Test { a = 1, b = 2.5f };
            Console.WriteLine(t3);
            Test t4 = new Test(100) { 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: 0, b: 0
a: 10, b: 0
a: 1, b: 2.5
a: 100, 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 = 1, b = 0.1f},
                new Test(100){b = 200.5f},
                null,
            };

            //哈希表
            Dictionary<int, Test> map = new Dictionary<int, Test>
            {
                {1001, new Test()},
                {1002, new Test{a = 1, b = 0.1f}},
                {1003, new Test(100){b = 200.5f}},
                {1004, 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 = 30};
            //这是不允许的
            //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, 10);
}

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

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

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

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

命名实参

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

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

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

Func(0, 10, true, "center", 30);

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

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