C#基础 [09] 属性

一、属性的定义和特征

　　1.属性的定义

　　　　属性是表示类或类的实例中的一个数据项的成员：它提供灵活的机制来读取、编写或计算某个私有字段的值。可以像使用公共数据成员一样使用属性，但实际上它们是称作“访问器”的特殊方法。这使得可以轻松访问数据，此外还有助于提高方法的安全性和灵活性。

　　2.属性的特征

　　　　1).属性是命名的类成员，它有类型，可以被赋值和读取。

　　　　2).与字段不同，属性是一个函数成员；它本身没有任何存储，不为数据存储分配内存；它执行代码。

　　　　3).属性有两个匹配的、称为访问器的方法：set访问器为属性赋值，get访问器从属性中获取值。

　　　　4).在使用属性时，属性访问器被隐式调用：当为属性赋值时，set访问器被隐式调用；当从属性中读取值时，get访问器被隐式调用；不能显式调用访问器。

　　3.属性的示例　　　

    class TimePeriod
    {
        // 声明一个后备字段
        private double seconds;

        // 声明一个doub类型的属性，在属性内部将小时转换为秒
        public double Hours
        {
            // get访问器：返回属性类型的值
            get { return seconds / 3600; }
            // set访问器：为属性赋值
            set { seconds = value * 3600; }
        }
    }    

    class Program
    {
        static void Main(string[] args)
        {
            TimePeriod t = new TimePeriod();

            // 为属性赋值,隐式调用set访问器.
            t.Hours = 24;

            // 读取属性值，隐式调用get访问器.
            System.Console.WriteLine("Time in hours: " + t.Hours);
        }
    }

二、属性访问器

　　属性的访问器就是两个方法，set访问器和get访问器有预定义的语法和语义。我们按照预定义的语法声明的属性，经过编译器编译之后，会自动分别为set访问器和get访问器生成相应的方法。编译器生成的方法经过反编译可以看得一清二楚。下面是我用Reflector反编译上例中的TimePeriod类之后，它的Hours属性的结构：

　　可以看到，编译器为Hours属性生成了一个返回值类型为void的方法名为set_Hours的方法，一个返回值类型为double的get_Hours方法。

　　1.set访问器

　　　　从上图已经可以看到了属性内部的结构。这里再来进一步分析属性所生成的setHours方法内部的秘密。经过反编译之后的set_Hours方法的内部代码如下：

public void set_Hours(double value)
{
    this.seconds = value * 3600.0;
}

　　　　从上面代码中我们可以分析得出set访问器的特征：

　　　　　　1).set访问器有一个单独的、隐式的值参数，参数名称为value，参数类型与属性的类型相同。

　　　　　　2).set访问器的返回类型为void。

　　2.get访问器

　　　　下面是get_Hours方法的内部实现代码：

public double get_Hours()
{
    return (this.seconds / 3600.0);
}

　　　　get访问器的特征：

　　　　　　1).get访问器没有参数。

　　　　　　2).get访问器有一个与属性类型一致的返回值类型。

　　　　　　3).get访问器的所有执行路径必须有一条return语句，返回属性类型的值。

三、属性和关联字段

　　1.属性通常和字段关联，字段存储实际的数据，而属性为字段提供了一种访问渠道。通常的做法是：在类中将字段声明为private，并且为字段声明一个public属性以提供受控的从类的外部对字段的访问。和属性关联的字段称为“后备字段"。

　　2.属性和后备字段有两种命名约定：

　　　　第一种：后备字段采用camel命名法，而属性采用字段的Pascal命名版本。

　　　　第二种：属性命名不变，仍然使用Pascal命名法，字段采用"下划线+camel"的形式。

　　 3.下面是另一个示例：该示例声明了一个名为Student的类，该类的每个属性都有一个采用了“_+camel”命名的后备字段。其中类成员声明按照：Fields—>Methods->Properties的顺序进行。

using System;
namespace MyClass
{
    class Student
    {
        // Fields
        private string _name;
        private string _sex;
        private int _age;
        private float _chinese;
        private float _math;
        private float _english;

        // Constructor
        public Student()
        {

        }

        // Methods
        public void SayHello()
        {
            System.Console.WriteLine("我叫{0}，今年{1}岁了,是{2}同学", this.Name, this.Age, this.Sex);
        }
        
        /// <summary>
        /// 总成绩
        /// </summary>
        /// <returns></returns>
        public float Sum()
        {
            return this.Chinese + this.Math + this.English;
        }

        /// <summary>
        /// 平均成绩
        /// </summary>
        /// <returns></returns>
        public float Average()
        {
            return (this.Chinese + this.Math + this.English) / 3f;
        }

        // Properties
        public string Name
        {
            get { return this._name; }
            set { this._name = value; }
        }

        public string Sex
        {
            get { return _sex; }
            set { _sex = value; }
        }

        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        public float Chinese
        {
            get { return _chinese; }
            set { _chinese = value; }
        }

        public float Math
        {
            get { return _math; }
            set { _math = value; }
        }

        public float English
        {
            get { return _english; }
            set { _english = value; }
        }
    }
}

四、只读属性和只写属性

　　1.只读属性：只有get访问器的属性称为只读属性。该属性使得只能将一项数据从类或类的实例传出，而不能有其它访问。

        public string Name
        {
            get { return this._name; }             
        }

　　2.只写属性：只有set访问器的属性称为只写属性。该属性值允许数据从类的外部传入类。

        public string Name
        {
            set { this._name = value; }
        }

　　3.属性必须有至少一个访问器，要么既可读、又可写，要么提供一个。不然编译器会报错。下面是我将Name属性的set访问器和get访问器都去掉之后报的一条错误消息：

五、属性与公共字段的比较

　　属性结合了字段和方法的多个方面。对于对象，属性显示为字段，访问属性需要与访问字段相同的语法。对于类的实现者（类本身），属性是一个或两个代码块，表示一个 get 访问器和/或一个 set 访问器。访问器可以对数据的访问提供一些限制和流程控制。

　　以下两点表明在实际编码中使用属性更好、更灵活：

　　　　1.字段是数据成员，只有存储能力，没有处理数据能力；而属性是函数成员，可以通过访问器对数据的输入输出进行控制。

　　　　2.程序编译之后，字段和属性的语义不同。

六、自动实现属性

　　1.从C#3.0中增加了自动实现属性（automatically implemented property），自动属性就是只声明属性而不声明后备字段，编译器会自动创建隐式的后备字段，并且自动与set和get访问器相关联。当属性的访问器中不需要其他逻辑时，自动实现的属性可使属性声明更加简洁。实际开发中，很多都是使用自动属性的。

　　2.自动实现属性的特征：

　　　　1).不必声明后备字段，编译器会根据属性的类型自动生成隐式的后备字段来存储数据。

　　　　2).不能提供访问器的方法体，set访问器和get访问器的方法体被一个分号代替。这也是符合逻辑的，因为都不知道后备字段是什么，当然无法对它提供访问控制了，这一切都交给了编译器。

　　　　3).必须同时提供读写属性，缺一不可。

　　3.示例

        // 自动实现属性
        public string Name
        {
            // 只有简单的get;和set;没有提供方法体
            get;
            set;
        }

　　4.自动实现属性的内部实现

// 由编译器生成的set访问器
[CompilerGenerated]
public void set_Name(string value)
{
    this.<Name>k__BackingField = value;
}

// 编译器生成的get访问器
[CompilerGenerated]
public string get_Name()
{
    return this.<Name>k__BackingField;
}

　　通过上面的代码可以看出，编译器为自动属性Name生成了名为“”的后备字段，并且生成了set_Name和get_Name两个访问器。

七、静态属性

　　1.静态属性与声明方式

　　　　可以在属性声明的类型前面加上static关键字声明静态属性。静态属性的特征如下：

　　　　　　1).不能访问类的实例成员。

　　　　　　2).不管类是否有实例，静态属性都是存在的。

　　　　　　3).访问方式：从类的内部访问时，与访问其他类成员一样；从类的外部访问时，需要使用“类型名.成员名”的方式。

　　2.示例

    class Trivial
    {
        // 声明一个静态自动实现属性
        public static int MyVale { get; set; }

        // 声明一个实例方法
        public void PrintValue()
        {
            // 从类内部的实例方法访问静态属性：与访问其他成员一样。
            Console.WriteLine("MyValue = {0}", MyVale);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            #region MyRegion
            TimePeriod t = new TimePeriod();

            // 为属性赋值,隐式调用set访问器.
            t.Hours = 24;

            // 读取属性值，隐式调用get访问器.
            System.Console.WriteLine("Time in hours: " + t.Hours); 
            #endregion

            // 从类的外部访问静态属性：使用"类名.属性名"的访问方式
            Trivial.MyVale = 10;
            Console.WriteLine(Trivial.MyVale);
        }
    }