C#属性访问修饰符进阶教程：自定义访问器逻辑的高级技巧

# 1. C#属性访问修饰符基础

## 1.1 C#属性访问修饰符概述

C#中的属性访问修饰符是用来控制属性的访问范围和可见性的关键字。它们定义了类成员的可访问性，包括属性、方法、字段等。正确地使用访问修饰符，能够帮助开发者遵循面向对象设计原则，如封装性、多态性和继承性。

## 1.2 属性访问修饰符的重要性

属性访问修饰符是确保代码健壮性和可维护性的关键因素。它们允许开发者限制对类内部状态的访问，保护对象的完整性，并且可以控制继承中成员的可见性。这对于创建可扩展和易于管理的代码库至关重要。

## 1.3 常见属性访问修饰符介绍

在C#中，常见的属性访问修饰符包括`public`、`private`、`protected`、`internal`以及这些修饰符的组合。下面章节我们将深入探讨每一种修饰符以及它们在实际开发中的应用和最佳实践。接下来，我们将从默认的访问行为开始，逐步分析每种修饰符的特点和用途。

# 2. 深入理解访问修饰符的作用域

## 2.1 属性访问修饰符的默认行为

### 2.1.1 类内访问

在C#中，当我们创建一个类并为其实例字段添加属性时，默认情况下，这些字段是私有的（private）。这意味着它们只能在类的内部被访问。这是C#封装原则的一个重要方面，旨在防止类的内部实现细节被外部代码直接访问，从而降低类之间的耦合性。

public class Person
{
    private string name; // 默认私有属性

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

在上述例子中，`name` 字段是私有的，不能直接在 `Person` 类外部访问。但是，我们通过公共属性 `Name` 提供了一个受控的访问方式，允许外部代码读取和设置 `name` 字段的值。

### 2.1.2 继承中的访问

当一个类继承自另一个类时，继承的类可以访问其基类中定义的公共（public）和受保护（protected）成员。然而，私有（private）成员和内部（internal）成员对派生类不可见。

public class Animal
{
    public string Type { get; set; } // 公共属性
    protected string Name { get; set; } // 受保护属性
}

public class Dog : Animal
{
    public void Speak()
    {
        // 可以访问基类的Type和Name
        Console.WriteLine($"I am a {Type} named {Name}.");
    }
}

在上述代码中，`Dog` 类继承自 `Animal` 类。`Dog` 类可以访问 `Animal` 类中的公共属性 `Type` 和受保护的属性 `Name`。但是，基类中的任何私有或内部成员对 `Dog` 类是不可见的。

## 2.2 访问修饰符的访问级别

### 2.2.1 公共访问（public）

公共访问修饰符 `public` 是最开放的访问级别，允许其他任何代码访问公共成员。

public class Program
{
    public static void Main()
    {
        Person person = new Person();
        person.Name = "Alice";
        Console.WriteLine(person.Name);
    }
}

// Person 类在上一节例子中定义

在这个示例中，`Main` 方法通过 `Person` 类的公共接口与 `Person` 类的实例交互。

### 2.2.2 私有访问（private）

私有访问修饰符 `private` 是最严格的访问级别，它限制了成员只能在定义它的类内访问。

public class Counter
{
    private int count;

    public Counter()
    {
        count = 0;
    }

    public void Increment()
    {
        count++;
    }

    private void Reset()
    {
        count = 0;
    }
}

在这个例子中，`Reset` 方法是私有的，因此它只能在 `Counter` 类的内部被调用。

### 2.2.3 内部访问（internal）

内部访问修饰符 `internal` 使得成员只能在其声明的程序集内被访问。

internal class Utility
{
    public static void DoSomething()
    {
        // 这个方法只能在同一个程序集中被访问
    }
}

使用 `internal` 可以隐藏对其他程序集不必要的成员，从而减少不必要的公开接口。

### 2.2.4 保护访问（protected）

保护访问修饰符 `protected` 允许派生类访问基类中的成员，但不允许其他代码访问。

public class Vehicle
{
    protected string licensePlate;

    public Vehicle(string plate)
    {
        licensePlate = plate;
    }
}

public class Car : Vehicle
{
    public Car(string plate) : base(plate) { }

    public void DisplayLicense()
    {
        // 可以访问基类中的受保护成员 licensePlate
        Console.WriteLine($"The car license plate is: {licensePlate}");
    }
}

在这个例子中，`licensePlate` 字段在基类 `Vehicle` 中是受保护的。它不能从基类外部访问，但可以被派生类 `Car` 访问。

## 2.3 访问修饰符的组合使用

### 2.3.1 受保护的内部（protected internal）

受保护的内部访问修饰符 `protected internal` 允许成员在一个程序集内的派生类或任何地方访问。

public class BaseClass
{
    protected internal void DoWork()
    {
        // 这个方法可以在派生类或者同一个程序集中访问
    }
}

public class DerivedClass : BaseClass
{
    public void Run()
    {
        DoWork(); // 可以访问，因为是派生类
    }
}

public class OtherClass
{
    public void Run()
    {
        BaseClass bc = new BaseClass();
        // bc.DoWork(); // 错误：不能访问，因为不是派生类
    }
}

在这个例子中，`DoWork` 方法只能被 `BaseClass` 的派生类或者同一个程序集内的其他类访问。

### 2.3.2 私有的受保护（private protected）

私有的受保护访问修饰符 `private protected` 是C# 7.2版本后引入的，它允许成员在一个程序集内的派生类中被访问。

public class BaseClass
{
    private protected void DoTask()
    {
        // 这个方法只能在同一个程序集的派生类中访问
    }
}

public class DerivedClass : BaseClass
{
    public void ExecuteTask()
    {
        DoTask(); // 可以访问，因为是派生类且在同一个程序集内
    }
}

public class OtherClass
{
    public void ExecuteTask()
    {
        BaseClass bc = new BaseClass();
        // bc.DoTask(); // 错误：不能访问，因为不是派生类
    }
}

`DoTask` 方法不能被 `BaseClass` 的其他实例或不同程序集的代码访问，它只限于同一程序集内的派生类。

通过本章的介绍，我们深入了解了C#属性访问修饰符在代码中的作用域及其对类设计的影响。接下来，在第三章中，我们将进一步探讨如何通过自定义属性的访问器来实现更复杂和灵活的数据访问逻辑。

# 3. 自定义属性的访问器

## 3.1 访问器的基本组成

### 3.1.1 get访问器

在C#中，属性是类或结构中的成员，它提供了一种灵活的方式来读取、写入或计算私有字段的值。get访问器用于获取属性的值，它必须返回与属性声明相同的类型。如果属性是只读的，则该属性只能包含get访问器，不得包含set访问器。

public class Person
{
    private string _name;

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

在上面的例子中，`Person` 类有一个名为 `_name` 的私有字段，以及一个名为 `Name` 的公开属性。`Name` 属性包含一个get访问器，它返回私有字段 `_name` 的值。注意，私有字段 `_name` 只能通过 `Name` 属性来访问，这提供了一种封装手段，以防止外部直接修改 `_name` 字段。

#### 参数说明与代码逻辑

- `private string _name;`：声明一个私有字段 `_name`，用于存储人名。
- `public string Name`：声明一个公开属性 `Name`。
- `{ get { return _name; } }`：`Name` 属性包含一个get访问器，用于返回 `_name` 字段的值。

通过这种方式，我们确保了 `_name` 字段的封装性，外部代码不能直接访问或修改 `_name`，只能通过 `Name` 属性进行间接访问。

### 3.1.2 set访问器

与get访问器相对应的是set访问器，它用于设置属性的值。set访问器包含一个隐式参数 `value`，该参数的类型与属性的类型相同。如果属性是只写的，则该属性只能包含set访问器，不得包含get访问器。

public class Person
{
    private string _name;

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

在修改后的 `Person` 类中，`Name` 属性现在包含了一个set访问器。这个set访问器允许外部代码通过 `Name` 属性来设置 `_name` 字段的值。

#### 参数说明与代码逻辑

- `{ set { _name = value; } }`：set访问器包含一个隐式参数 `value`，这个 `value` 参数将被赋予 `_name` 字段新的值。

通过使用set访问器，我们可以在将值赋给字段之前添加额外的逻辑检查。例如，可以确保名字不为空或不包含非法字符。

## 3.2 访问器的高级特性

### 3.2.1 访问器中使用条件逻辑

在访问器中可以使用条件逻辑来控制属性值的赋值或返回。这允许在赋值时加入业务规则，或在返回值之前进行计算。

public class Person
{
    private int _age;

    public int Age
    {
        get { return _age; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentOutOfRangeException("Age cannot be negative.");
            }
            _age = va