第二部分设计类型：第10章属性

属性：无参属性 + 有参属性(索引器)

10.1 无参属性
强烈建议所有字段都设为private。通过属性的方式来封装字段，可对数据进行非法值判断。
封装了字段访问的方法称为访问器(accessor)方法。

可将属性理解为智能字段，背后有额外逻辑的字段。属性通过get和set方法可以设置读写。
私有字段通常称为支持字段(backing field)。

属性编译后，编译器在最后的托管程序集中生成以下两项或三项：
•代表属性的get访问器的一个方法。仅在属性定义了get访问器时生成。
•代表属性的set访问器的一个方法。仅在属性定义了set访问器方法时生成。
•托管程序集元数据中的一个属性定义。这一项一定生成。

编译器编译代码发现对字段进行访问和设置的时候，会自动生成get_或set_为前缀的访问器方法，生成对访问器的调用。

10.1.1 自动实现的属性
自动实现的属性(Automatially Implemented Property,后面称AIP)。仅仅为了封装支持字段。必须是可读可写的才可使用。
public string Name{get;set;} //仅这样写，编译器会自动声明一个私有字段，并自动实现get_Name和set_Name方法。

任何想要序列化或反序列化的类中，都不要使用自动属性功能。因为AIP自动生成的支持字段名称不固定。

10.1.2 合理定义属性
属性本质上是方法。
如果需要线程同步，就不应使用属性。从MashalByRefObject派生的类永远都不应该使用属性。
属性和普通方法相比，对性能损耗更大，还会妨碍对代码的理解。

10.1.3 对象和集合初始化器
对象初始化器：
Employee e = new Employee(){Name = "Jeff", Age = 45}; //构造对象、调用无参构造器、设置属性
等价于以下代码：

Emploee e = new Employee();
e.Name = "Jeff";
e.Age = 45;

对象初始化器的好处：
允许在表达式的上下文中编码，允许组合多个函数，增强代码的可读性。如：
String s = new Employee(){Name="Jeff",Age=45}.ToString().ToUpper();

补充：
如果调用的是无参构造器，大括号可省略，可简写为：
string s = new Employee {Name="Jeff",Age=45}.ToString().ToUpper();

如果一个属性的类型实现了IEnumerable或IEnumerable<T>接口，属性就是一个集合。
集合的初始化时一种相加操作，而非替换操作。

集合初始化器：

public sealed class Classroom
{
private List<String> m_students = new List<String>();
public List<String> Students {get{ return m_students;}}

public Classroom(){}
}

构造一个Classroom对象，并像下面这样初始化Students集合：

public static void M()
{
 Classroom classroom = new Classroom{
 Students ={"Jeff","Kristin","Aidan","Grant"}
 }
}

Students ={"Jeff","Kristin","Aidan","Grant"} //Students为List<String>类型
编译时，编译器发现Students属性的类型是List<String>类型，而这个类型实现了IEnumerable<String>接口。编译器就假定List<String>类型提供了一个名为Add的方法。然后编译器生成代码来调用集合的Add方法，上述代码编译转化为：

public static void M()
{
Classroom classrom = new Classroom();
classroom.Students.Add("Jeff");
classroom.Students.Add("Kristin");
classroom.Students.Add("Aidan");
classroom.Students.Add("Grant");
}

如果属性的类型实现了IEnumerable或IEnumerable<T>,但未提供Add方法，编译器报错：
error CS0117："System.Collections.Generic.IEnumerable<string>"不包含"Add"的定义。

有些集合的Add方法要获取多个实参，比如Dictionary的Add方法：
public void Add(TKey key,TValue value);

通过在集合初始化器中嵌套大括号的方式，可向Add方法传递多个实参，如下所示：

var table = new Dictionary<String,Int32>{
  {"Jeffrey",1},{"Kristin",2},{"Aidan",3},{"Grant",4}
}

以上代码等价于下述代码：

var table = new Dictionary<String,Int32>();
table.Add("Jeffrey",1);
table.Add("Kristin",2);
table.Add("Aidan",3);
table.Add("Grant",4);

10.1.4 匿名类型
C#利用匿名可以声明一个不可变的元组类型。元组类型是含有一组属性的类型，这些属性通常以某种方式相互关联。 //元组英文tuple 是对顺序的一个抽象：single,double,triple,quadruple,quintuple

//定义一个类型，构造他的一个实例，并初始化它的属性
var o1 = new {Name="Jeff",Year=1964};
var利用C#的隐式类型局部变量功能。
//在控制台上显示属性：
Console.WriteLine("Name={0},Year={1}",o1.Name,o1.Year);

var o = new {propety1= expression1,...,propertyN=expressionN};
编译器会推断每个表达式的类型，创建推断类型的私有字段，为每个字段创建公共只读属性，并创建一个构造器来接收所有这些表达式。在构造器的代码中，会用传给它的表达式的求值结果来初始化私有只读字段。
另外，编译器还会重写Object的Equals，GetHashCode和ToString方法，并生成所有这些方法中的代码。
最终看起来像这样：

第二部分设计类型：第10章属性

10.1.5 System.Tuple类型
Tuple组元一般用于方法返回多个类型数据，就可以不用out,ref输出参数了。组元是C#4.0引入的新特性，需要.NEF Framework4.0及以上版本。

简单例子：

public class Point
{
   public int X { get; set; }
   public int Y { get; set; }
 }
Point p = new Point() { X = 10, Y = 20 };
//use the predefine generic tuple type.
Tuple<int, int> p2 = new Tuple<int, int>(10, 20);

Console.WriteLine(p.X + p.Y);
Console.WriteLine(p2.Item1 + p2.Item2);

一个简单的包含两个Int类型成员的类，传统的方法定义point需要写很多代码，但是使用tuple却只有一句。

感觉比较像ArrayList：可以放不同类型的数据到集合中

ArrayList list = new ArrayList();
list.Add(3);
list.Add("Hello World");
Response.Write(list[0]+list[1].ToString());

第二部分设计类型：第10章属性

复杂一些的：

Tuple<int> test = new Tuple<int>(1);
Tuple<int, int> test2 = Tuple.Create<int, int>(1,2);
Console.WriteLine(test.Item1);
Console.WriteLine(test2.Item1 + test2.Item2);

Tuple<int, int, int, int, int, int, int, Tuple<int>> test3 = new Tuple<int, int, int, int, int, int, int, Tuple<int>>(1, 2, 3, 4, 5, 6, 7, new Tuple<int>(8));
Console.WriteLine(test3.Item1 + test3.Item2 + test3.Item3 + test3.Item4 + test3.Item5 + test3.Item6 + test3.Item7 + test3.Rest.Item1);

第一个定义包含一个成员。

第二个定义包含两个成员，并且使用create方法初始化。

第三个定义展示了tuple最多支持8个成员，如果多于8个就需要进行嵌套。注意第8个成员很特殊，如果有8个成员，第8个必须嵌套定义tuple。

嵌套定义的例子：

Tuple<int, Tuple<int>> test4 = new Tuple<int, Tuple<int>>(1, new Tuple<int>(2));
Console.WriteLine(test4.Item1 + test4.Item2.Item1);

Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>> test5 = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>>(1, 2, 3, 4, 5, 6, 7, new Tuple<int, int, int>(8, 9, 10));

Console.WriteLine(test5.Item1 + test5.Item2 + test5.Item3 + test5.Item4 + test5.Item5 + test5.Item6 + test5.Item7 + test5.Rest.Item1 + test5.Rest.Item2 + test5.Rest.Item3);

10.2 有参属性

有参属性，是指属性中的get访问器方法接受一个或多个参数，set接受两个或多个参数。C#称有参属性为“索引器”。理解：无参属性是设置单一数据的。索引器是设置数组字段的。

简单索引器例子：

public class IndexerClass
{
    private string[] name = new string[2];
    
    //索引器必须以this关键字定义，其实这个this就是类实例化之后的对象
    public string this[int index]
    {
        get //实现索引器的get方法
        {
            if (index < 2)
            {
                return name[index];
            }
            return null;
        }

        set //实现索引器的set方法
        {
            if (index < 2)
            {
                name[index] = value;
            }
        }
    }
}
public class Test
{
    static void Main()
    {
        //索引器的使用
       IndexerClass Indexer = new IndexerClass();
       Indexer[0] = "张三"; //“=”号右边对索引器赋值，其实就是调用其set方法
       Indexer[1] = "李四";//输出索引器的值，其实就是调用其get方法

       Console.WriteLine(Indexer[0]);
       Console.WriteLine(Indexer[1]);
    }
}

以字符串作为下标，对索引器进行存取：

public class IndexerClass
{
    //用string作为索引器下标的时候，要用Hashtable
    private Hashtable name = new Hashtable();

    //索引器必须以this关键字定义，其实这个this就是类实例化之后的对象
    public string this[string index]
    {
        get { return name[index].ToString(); 
        set { name.Add(index, value); }
    }
}
public class Test
{
    static void Main()
    {
        IndexerClass Indexer = new IndexerClass();
        Indexer["A0001"] = "张三";
        Indexer["A0002"] = "李四";
        Console.WriteLine(Indexer["A0001"]);
        Console.WriteLine(Indexer["A0002"]);
    }
}

View Code