C#类成员-属性
C#类成员 – 属性
它们提供灵活的机制来读取、编写或计算私有字段的值。可以像使用公共数据成员一样使用属性，但实际上它们是称作“访问器”的特殊方法。这使得可以轻松访问数据，此外还有助于提高方法的安全性和灵活性。
在本示例中，TimePeriod 类存储一个时间段。在内部，类以秒为单位存储时间，但客户端使用名为 Hours 的属性能够以小时为单位指定时间。Hours 属性的访问器执行小时和秒之间的转换。
class TimePeriod
{
private double seconds;
public double Hours
{
get { return seconds / 3600; }
set { seconds = value * 3600; }
}
}
class Program
{
static void Main()
{
TimePeriod t = new TimePeriod();
// Assigning the Hours property causes the 'set' accessor to be called.
t.Hours = 24;
// Evaluating the Hours property causes the 'get' accessor to be called.
System.Console.WriteLine("Time in hours: " + t.Hours);
}
}
// Output: Time in hours: 24
属性使类能够以一种公开的方法获取和设置值，同时隐藏实现或验证代码。
get 属性访问器用于返回属性值，而 set 访问器用于分配新值。这些访问器可以有不同的访问级别。
value 关键字用于定义由 set 索引器分配的值。
不实现 set 方法的属性是只读的。
对于不需要任何自定义访问器代码的简单属性，可考虑选择使用自动实现的属性。
1、使用属性
属性结合了字段和方法的多个方面。
属性是一个 get 访问器和/或一个 set 访问器来表示。当读取属性时，执行 get 访问器的代码块；当向属性分配一个新值时，执行 set 访问器的代码块。不具有 set 访问器的属性被视为只读属性。不具有 get 访问器的属性被视为只写属性。同时具有这两个访问器的属性是读写属性。
public class Date
{
private int month = 7; // Backing store
public int Month
{
get
{
return month;
}
set
{
if ((value > 0) && (value < 13))
{
month = value;
}
}
}
}
在此示例中，Month 是作为属性声明的，这样 set 访问器可确保 Month 值设置为 1 和 12 之间。Month 属性使用私有字段来跟踪实际值。属性的数据的真实位置经常称为属性的“后备存储”。属性使用作为后备存储的私有字段是很常见的。将字段标记为私有可确保该字段只能通过调用属性来更改。
get 访问器
get 访问器体与方法体相似。它必须返回属性类型的值。执行 get 访问器相当于读取字段的值。例如，当正在从 get 访问器返回私有变量并且启用了优化时，对 get 访问器方法的调用由编译器进行内联，因此不存在方法调用的系统开销。然而，由于在编译时编译器不知道在运行时实际调用哪个方法，因此无法内联虚拟 get 访问器。以下是返回私有字段 name 的值的 get 访问器：
class Person
{
private string name; // the name field
public string Name // the Name property
{
get
{
return name;
}
}
}
当引用属性时，除非该属性为赋值目标，否则将调用 get 访问器以读取该属性的值。例如：
Person person = new Person();
//...
System.Console.Write(person.Name); // the get accessor is invoked here
get访问器必须以 return 或 throw 语句终止，并且控制权不能离开访问器体。
通过使用 get 访问器更改对象的状态不是一种好的编程风格。例如，以下访问器在每次访问 number 字段时都会产生更改对象状态的副作用。
private int number;
public int Number
{
get
{
return number++; // Don't do this
}
}
get 访问器可用于返回字段值，或用于计算并返回字段值。例如：
class Employee
{
private string name;
public string Name
{
get
{
return name != null ? name : "NA";
}
}
}
在上一个代码段中，如果不对 Name 属性赋值，它将返回值 NA。
set 访问器
set 访问器类似于返回类型为 void 的方法。它使用称为 value 的隐式参数，此参数的类型是属性的类型。在下面的示例中，将 set 访问器添加到 Name 属性：
class Person
{
private string name; // the name field
public string Name // the Name property
{
get
{
return name;
}
set
{
name = value;
}
}
}
当对属性赋值时，用提供新值的参数调用 set 访问器。例如：
Person person = new Person();
person.Name = "Joe"; // the set accessor is invoked here
System.Console.Write(person.Name); // the get accessor is invoked here
在 set 访问器中，对局部变量声明使用隐式参数名称 value 是错误的。
可将属性标记为 public、private、protected、internal 或 protected internal。这些访问修饰符定义类的用户如何才能访问属性。同一属性的 get 和 set 访问器可能具有不同的访问修饰符。例如，get 可能是 public 以允许来自类型外的只读访问；set 可能是 private 或 protected。
可以使用 static 关键字将属性声明为静态属性。这使得调用方随时可使用该属性，即使不存在类的实例。
可以使用 virtual 关键字将属性标记为虚属性。这样，派生类就可以通过使用 override 关键字来重写事件行为。
重写虚属性的属性还可以是 sealed 的，这表示它对派生类不再是虚拟的。最后，可以将属性声明为 abstract。这意味着类中没有任何实现，派生类必须编写自己的实现。
对 static 属性的访问器使用 virtual、abstract 或 override 修饰符是错误的。
此例说明了实例、静态和只读属性。它从键盘接受雇员的姓名，按 1 递增 NumberOfEmployees，并显示雇员的姓名和编号。
public class Employee
{
public static int NumberOfEmployees;
private static int counter;
private string name;
// A read-write instance property:
public string Name
{
get { return name; }
set { name = value; }
}
// A read-only static property:
public static int Counter
{
get { return counter; }
}
// A Constructor:
public Employee()
{
// Calculate the employee's number:
counter = ++counter + NumberOfEmployees;
}
}
class TestEmployee
{
static void Main()
{
Employee.NumberOfEmployees = 107;
Employee e1 = new Employee();
e1.Name = "Claude Vige";
System.Console.WriteLine("Employee number: {0}", Employee.Counter);
System.Console.WriteLine("Employee name: {0}", e1.Name);
}
}
/* Output:
Employee number: 108
Employee name: Claude Vige
*/
此示例说明如何访问基类中由派生类中具有同一名称的另一个属性所隐藏的属性。
public class Employee
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
}
public class Manager : Employee
{
private string name;
// Notice the use of the new modifier:
public new string Name
{
get { return name; }
set { name = value + ", Manager"; }
}
}
class TestHiding
{
static void Main()
{
Manager m1 = new Manager();
// Derived class property.
m1.Name = "John";
// Base class property.
((Employee)m1).Name = "Mary";
System.Console.WriteLine("Name in the derived class is: {0}", m1.Name);
System.Console.WriteLine("Name in the base class is: {0}", ((Employee)m1).Name);
}
}
/* Output:
Name in the derived class is: John, Manager
Name in the base class is: Mary
*/
以下是上一个示例中的要点：
派生类中的属性 Name 隐藏基类中的属性 Name。在这种情况下，派生类的属性声明中使用 new 修饰符：
public new string Name
转换 (Employee) 用于访问基类中的隐藏属性：
((Employee)m1).Name = "Mary";
在此例中，Cube 和 Square 这两个类实现抽象类 Shape，并重写它的抽象 Area 属性。注意属性上 override 修饰符的使用。程序接受输入的边长并计算正方形和立方体的面积。它还接受输入的面积并计算正方形和立方体的相应边长。
abstract class Shape
{
public abstract double Area
{
get;
set;
}
}
class Square : Shape
{
public double side;
public Square(double s) //constructor
{
side = s;
}
public override double Area
{
get
{
return side * side;
}
set
{
side = System.Math.Sqrt(value);
}
}
}
class Cube : Shape
{
public double side;
public Cube(double s)
{
side = s;
}
public override double Area
{
get
{
return 6 * side * side;
}
set
{
side = System.Math.Sqrt(value / 6);
}
}
}
class TestShapes
{
static void Main()
{
// Input the side:
System.Console.Write("Enter the side: ");
double side = double.Parse(System.Console.ReadLine());
// Compute the areas:
Square s = new Square(side);
Cube c = new Cube(side);
// Display the results:
System.Console.WriteLine("Area of the square = {0:F2}", s.Area);
System.Console.WriteLine("Area of the cube = {0:F2}", c.Area);
System.Console.WriteLine();
// Input the area:
System.Console.Write("Enter the area: ");
double area = double.Parse(System.Console.ReadLine());
// Compute the sides:
s.Area = area;
c.Area = area;
// Display the results:
System.Console.WriteLine("Side of the square = {0:F2}", s.side);
System.Console.WriteLine("Side of the cube = {0:F2}", c.side);
}
}
/* Example Output:
Enter the side: 4
Area of the square = 16.00
Area of the cube = 96.00
Enter the area: 24
Side of the square = 4.90
Side of the cube = 2.00
*/
2、接口属性
可以在接口上声明属性。以下是接口索引器访问器的示例：
public interface ISampleInterface
{
// Property declaration:
string Name
{
get;
set;
}
}
接口属性的访问器不具有体。因此，访问器的用途是指示属性是否为读写、只读或只写。
在此例中，接口 IEmployee 具有读写属性 Name 和只读属性 Counter。Employee 类实现 IEmployee 接口并使用这两种属性。程序读取新雇员的姓名和雇员的当前编号，并显示雇员姓名和计算所得的雇员编号。
可以使用属性的完全限定名，它引用声明成员的接口。例如：
string IEmployee.Name
{
get { return "Employee Name"; }
set { }
}
这称为显式接口实现。例如，如果 Employee 类实现两个接口 ICitizen 和 IEmployee，并且两个接口都具有 Name 属性，则需要显式接口成员实现。即，如下属性声明：
string IEmployee.Name
{
get { return "Employee Name"; }
set { }
}
在 IEmployee 接口上实现 Name 属性，而下面的声明：
string ICitizen.Name
{
get { return "Citizen Name"; }
set { }
}
在 ICitizen 接口上实现 Name 属性。
interface IEmployee
{
string Name
{
get;
set;
}
int Counter
{
get;
}
}
public class Employee : IEmployee
{
public static int numberOfEmployees;
private string name;
public string Name // read-write instance property
{
get
{
return name;
}
set
{
name = value;
}
}
private int counter;
public int Counter // read-only instance property
{
get
{
return counter;
}
}
public Employee() // constructor
{
counter = ++counter + numberOfEmployees;
}
}
class TestEmployee
{
static void Main()
{
System.Console.Write("Enter number of employees: ");
Employee.numberOfEmployees = int.Parse(System.Console.ReadLine());
Employee e1 = new Employee();
System.Console.Write("Enter the name of the new employee: ");
e1.Name = System.Console.ReadLine();
System.Console.WriteLine("The employee information:");
System.Console.WriteLine("Employee number: {0}", e1.Counter);
System.Console.WriteLine("Employee name: {0}", e1.Name);
}
}
210
Hazem Abolrous
3、非对称访问器可访问性
属性或索引器的 get 和 set 部分称为“访问器”。默认情况下，这些访问器具有相同的可见性或访问级别：其所属属性或索引器的可见性或访问级别。不过，有时限制对其中某个访问器的访问会很有用。通常是在保持 get 访问器可公开访问的情况下，限制 set 访问器的可访问性。例如：
private string name = "Hello";
public string Name
{
get
{
return name;
}
protected set
{
name = value;
}
}
在此示例中，名为 Name 的属性定义了一个 get 访问器和一个 set 访问器。get 访问器接受该属性本身的可访问性级别（在此示例中为 public），而对于 set 访问器，则通过对该访问器本身应用 protected 访问修饰符来进行显式限制。
对访问器的访问修饰符的限制 :
对属性或索引器使用访问修饰符受以下条件的制约：
·不能对接口或显式接口成员实现使用访问器修饰符。
·仅当属性或索引器同时具有 set 和 get 访问器时，才能使用访问器修饰符。这种情况下，只允许对其中一个访问器使用修饰符。
·如果属性或索引器具有 override 修饰符，则访问器修饰符必须与重写的访问器的访问器（如果有的话）匹配。
·访问器的可访问性级别必须比属性或索引器本身的可访问性级别具有更严格的限制。
重写访问器的访问修饰符
在重写属性或索引器时，被重写的访问器对重写代码而言，必须是可访问的。此外，属性/索引器和访问器的可访问性级别都必须与相应的被重写属性/索引器和访问器匹配。例如：
public class Parent
{
public virtual int TestProperty
{
// Notice the accessor accessibility level.
protected set { }
// No access modifier is used here.
get { return 0; }
}
}
public class Kid : Parent
{
public override int TestProperty
{
// Use the same accessibility level as in the overridden accessor.
protected set { }
// Cannot use access modifier here.
get { return 0; }
}
}
实现接口
使用访问器实现接口时，访问器不能具有访问修饰符。但是，如果使用一个访问器（如 get）实现接口，则另一个访问器可以具有访问修饰符，如下面的示例所示：
public interface ISomeInterface
{
int TestProperty
{
// No access modifier allowed here
// because this is an interface.
get;
}
}
public class TestClass : ISomeInterface
{
public int TestProperty
{
// Cannot use access modifier here because
// this is an interface implementation.
get { return 10; }
// Interface property does not have set accessor,
// so access modifier is allowed.
protected set { }
}
}
访问器可访问性域
如果对访问器使用访问某个修饰符，则访问器的可访问性域由该修饰符确定。
如果不对访问器使用访问修饰符，则访问器的可访问性域由属性或索引器的可访问性级别确定。
下面的示例包含三个类：BaseClass、DerivedClass 和 MainClass。每个类的 BaseClass、Name 和 Id 都有两个属性。该示例演示在使用限制性访问修饰符（如 protected 或 private）时，如何通过 BaseClass 的 Id 属性隐藏 DerivedClass 的 Id 属性。因此，向该属性赋值时，将调用 BaseClass 类中的属性。将访问修饰符替换为 public 将使该属性可访问。
该示例还演示 DerivedClass 的 Name 属性的 set 访问器上的限制性访问修饰符（如 private 或 protected）如何防止对该访问器的访问，并在向它赋值时生成错误。
public class BaseClass
{
private string name = "Name-BaseClass";
private string id = "ID-BaseClass";
public string Name
{
get { return name; }
set { }
}
public string Id
{
get { return id; }
set { }
}
}
public class DerivedClass : BaseClass
{
private string name = "Name-DerivedClass";
private string id = "ID-DerivedClass";
new public string Name
{
get
{
return name;
}
// Using "protected" would make the set accessor not accessible.
set
{
name = value;
}
}
// Using private on the following property hides it in the Main Class.
// Any assignment to the property will use Id in BaseClass.
new private string Id
{
get
{
return id;
}
set
{
id = value;
}
}
}
class MainClass
{
static void Main()
{
BaseClass b1 = new BaseClass();
DerivedClass d1 = new DerivedClass();
b1.Name = "Mary";
d1.Name = "John";
b1.Id = "Mary123";
d1.Id = "John123"; // The BaseClass.Id property is called.
System.Console.WriteLine("Base: {0}, {1}", b1.Name, b1.Id);
System.Console.WriteLine("Derived: {0}, {1}", d1.Name, d1.Id);
// Keep the console window open in debug mode.
System.Console.WriteLine("Press any key to exit.");
System.Console.ReadKey();
}
}
/* Output:
Base: Name-BaseClass, ID-BaseClass
Derived: John, ID-BaseClass
*/
4、如何声明/使用读/写属性
属性可以提供公共数据成员的便利，而又不会带来不受保护、不受控制以及未经验证访问对象数据的风险。这是通过“访问器”来实现的：访问器是为基础数据成员赋值和检索其值的特殊方法。使用 set 访问器可以为数据成员赋值，使用 get 访问器可以检索数据成员的值。
此示例演示 Person 类，该类具有两个属性：Name (string) 和 Age (int)。这两个属性都提供 get 和 set 访问器，因此它们被视为读/写属性。
class Person
{
private string name = "N/A";
private int age = 0;
// Declare a Name property of type string:
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}
// Declare an Age property of type int:
public int Age
{
get
{
return age;
}
set
{
age = value;
}
}
public override string ToString()
{
return "Name = " + Name + ", Age = " + Age;
}
}
class TestPerson
{
static void Main()
{
// Create a new Person object:
Person person = new Person();
// Print out the name and the age associated with the person:
Console.WriteLine("Person details - {0}", person);
// Set some values on the person object:
person.Name = "Joe";
person.Age = 99;
Console.WriteLine("Person details - {0}", person);
// Increment the Age property:
person.Age += 1;
Console.WriteLine("Person details - {0}", person);
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/* Output:
Person details - Name = N/A, Age = 0
Person details - Name = Joe, Age = 99
Person details - Name = Joe, Age = 100
*/
可靠编程
在上面的示例中，Name 和 Age 属性是公共的，并且同时包含 get 和 set 访问器。这允许任何对象读写这些属性。不过，有时需要排除其中的一个访问器。例如，省略 set 访问器将使该属性成为只读的：
public string Name
{
get
{
return name;
}
}
此外，您还可以公开一个访问器，而使另一个访问器成为私有的或受保护的。
声明了属性后，可像使用类的字段那样使用这些属性。这使得获取和设置属性值时都可以使用非常自然的语法，如以下语句中所示：
person.Name = "Joe";
person.Age = 99;
注意，属性 set 方法中可以使用一个特殊的 value 变量。该变量包含用户指定的值，例如：
name = value;
请注意用于使 Person 对象上的 Age 属性递增的简洁语法：
person.Age += 1;
如果将单独的 set 和 get 方法用于模型属性，则等效代码可能类似于：
复制代码
person.SetAge(person.GetAge() + 1);
本示例中重写了 ToString 方法：
public override string ToString()
{
return "Name = " + Name + ", Age = " + Age;
}
注意，程序中未显式使用 ToString。默认情况下，它由 WriteLine 调用来调用。
5、自动实现的属性
当属性访问器中不需要其他逻辑时，自动实现的属性可使属性声明变得更加简洁。当您如下面的示例所示声明属性时，编译器将创建一个私有的匿名后备字段，该字段只能通过属性的 get 和 set 访问器进行访问。
下面的示例演示了一个具有某些自动实现的属性的简单类：
class LightweightCustomer
{
public double TotalPurchases { get; set; }
public string Name { get; private set; } // read-only
public int CustomerID { get; private set; } // read-only
}
自动实现的属性必须同时声明 get 和 set 访问器。若要创建 readonly 自动实现属性，请给予它 private set 访问器。
可以在自动实现的属性 (Property) 上使用属性 (Attribute)，但由于属性 (Attribute) 不可从源代码访问，显然不能用在支持字段上。如果您必须在属性 (Property) 的后备字段上使用属性 (Attribute)，则应该只创建常规属性 (Property)。
6、如何使用自动实现的属性实现轻量类
本示例演示如何创建一个仅用于封装一组自动实现的属性的轻量类。当您必须使用引用类型语义时，请使用此种构造而不是结构。
public class Contact
{
public string Name { get; set; }
public string Address { get; set; }
public int ContactNumber { get; set; }
public int ID { get; private set; } // readonly
}
编译器为每个自动实现的属性创建了后备字段。这些字段无法直接从源代码进行访问。