第二部分 设计类型：第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.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());

 

 

 

复杂一些的：

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"]);
    }
}

索引器的重载：

public class IndexerClass
{
    private Hashtable name = new Hashtable();

    //1：通过key存取Values
    public string this[int index]
    {
        get { return name[index].ToString(); }
        set { name.Add(index, value); }
    }

    //2：通过Values存取key
    public int this[string aName]
    {
        get
        {
            //Hashtable中实际存放的是DictionaryEntry(字典)类型，如果要遍历一个Hashtable，就需要使用到DictionaryEntry
            foreach(DictionaryEntry d in name)
            {
                if (d.Value.ToString() == aName)
                {
                    return Convert.ToInt32(d.Key);
                }
            }
            return -1;
        }
        set
        {
            name.Add(value, aName);
        }
    }
}
public class Test
{
    static void Main()
    {
        IndexerClass Indexer = new IndexerClass();

        //第一种索引器的使用
        Indexer[1] = "张三";//set访问器的使用
        Indexer[2] = "李四";
       Console.WriteLine("编号为1的名字：" + Indexer[1]);//get访问器的使用
        Console.WriteLine("编号为2的名字：" + Indexer[2]);

        Console.WriteLine();
        //第二种索引器的使用
        Console.WriteLine("张三的编号是：" + Indexer["张三"]);//get访问器的使用
        Console.WriteLine("李四的编号是：" + Indexer["李四"]);
       Indexer["王五"] = 3;//set访问器的使用
        Console.WriteLine("王五的编号是：" + Indexer["王五"]);
    }
}

多参索引器：

using System;
using System.Collections;

//入职信息类
public class EntrantInfo
{
    //姓名、编号、部门
    private string name;
    private int number;
    private string department;
    public EntrantInfo()
    {

    }
    public EntrantInfo(string name, int num, string department)
    {
        this.name = name;
        this.number = num;
        this.department = department;
    }

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

    public int Num
    {
        get { return number; }
        set { number = value; }
    }

    public string Department
    {
        get { return department; }
        set { department = value; }
    }
}

//声明一个类EntrantInfo的索引器
public class IndexerForEntrantInfo
{
    private ArrayList ArrLst;//用于存放EntrantInfo类
    public IndexerForEntrantInfo()
    {
        ArrLst = new ArrayList();
    }

    //声明一个索引器：以名字和编号查找存取部门信息
    public string this[string name, int num]
    {
        get
        {
            foreach (EntrantInfo en in ArrLst)
            {
                if (en.Name == name && en.Num == num)
                {
                    return en.Department;
                }
            }
            return null;
        }
        set
        {
            //new关键字：C#规定，实例化一个类或者调用类的构造函数时，必须使用new关键
            ArrLst.Add(new EntrantInfo(name, num, value));
        }
    }

    //声明一个索引器：以编号查找名字和部门
    public ArrayList this[int num]
    {
        get
        {
            ArrayList temp = new ArrayList();
            foreach (EntrantInfo en in ArrLst)
            {
                if (en.Num == num)
                {
                    temp.Add(en);
                }
            }
            return temp;
        }
    }

    //还可以声明多个版本的索引器...
}

public class Test
{
    static void Main()
    {
        IndexerForEntrantInfo Info = new IndexerForEntrantInfo();
        //this[string name, int num]的使用
        Info["张三", 101] = "人事部";
        Info["李四", 102] = "行政部";
        Console.WriteLine(Info["张三", 101]);
        Console.WriteLine(Info["李四", 102]);

        Console.WriteLine();

        //this[int num]的使用
        foreach (EntrantInfo en in Info[102])
        {
            Console.WriteLine(en.Name);
            Console.WriteLine(en.Department);
        }
    }
}

 

索引器与属性的比较：

索引器与属性都是类的成员，语法上非常相似。索引器一般用在自定义的集合类中，通过使用索引器来操作集合对象就如同使用数组一样简单；而属性可用于任何自定义类，它增强了类的字段成员的灵活性。

 

10.3 调用属性访问器方法时的性能

对于简单的get和set访问器方法，JIT编译器会将代码内联(inline)。这样使用属性就没有性能上的损失。内联是指将一个方法(或当前情况下的访问器方法)的代码直接编译到调用它的方法中。这便避免了再运行时发出调用所产生的开销，代价是编译好的方法的代码会变得更大。由于属性访问器方法通常只包含极少量代码，所以对它们进行内联，反而会使最终生成的代码变得更小，而且执行得更快。

注意，JIT编译器在调试代码时不会内联属性方法，因为内联的代码会变得难以调试。所以程序在发布版本中访问属性时的性能比较快，在调试版本中比较慢。字段访问无论调试或发布都很快。

 

10.4 属性访问器的可访问性
对get和set设置不同的可访问性：

public class SomeType{
  private string m_name;
  public string Name{
   get{return m_name;}
   protected set{m_name=value;} //只能设置比整体的public限制更大的可访问性
  }
}

10.5 泛型属性访问器方法
属性虽然本质上是方法，但属性还是不能引入自己的泛型类型参数，引文从概念上讲不通。属性本应该表示读写的对象特征。如果引入泛型参数，读写行为可能发生改变。
但从概念上说，属性是不应该具有行为的。要公开对象的行为，不管是不是泛型，应该定义方法而非属性。