在C#编程中，属性（Property）和方法（Method）是定义类和对象行为的两个关键概念。它们使程序能够封装数据、实现功能并确保代码的健壮性和可维护性。本文将详细介绍属性和方法的应用特点，探讨它们在不同场景下的使用，并通过多个示例展示如何在实际编程中有效运用属性和方法。

---

属性（Property）

属性提供了一种控制对类中私有字段的访问方式，允许在读取或写入值时执行自定义逻辑，如数据验证。属性使得类的使用者可以像访问公共字段一样访问数据，但同时保留了封装的优势。

属性的基本用法

C#
public class Person
{
    private string name; // 私有字段

    public string Name
    {
        get { return name; } // 获取器：返回私有字段的值
        set { name = value; } // 设置器：设置私有字段的值
    }
}

示例：

C#
internal class Program
{
    static void Main(string[] args)
    {
        Person person = new Person();
        person.Name = "Alice"; // 设置属性值
        Console.WriteLine($"Person's name: {person.Name}"); // 获取属性值
    }
}

输出：

自动属性

当属性的获取和设置不需要额外的逻辑时，可以使用自动属性简化代码。

C#
public class Person
{
    public string Name { get; set; } // 自动属性
}

示例：

C#
Person person = new Person();
person.Name = "Bob";
Console.WriteLine($"Person's name: {person.Name}");

输出：

只读和只写属性

• 只读属性：只有get访问器，外部代码只能读取，不能修改。
• 只写属性：只有set访问器，外部代码只能设置，不能读取。

只读属性示例：

C#
public class Product
{
    private readonly string id = Guid.NewGuid().ToString();

    public string ID
    {
        get { return id; }
    }
}

示例：

C#
Product product = new Product();
Console.WriteLine($"Product ID: {product.ID}");

输出：

属性中的数据验证

可以在属性的设置器中添加数据验证逻辑，确保属性值的有效性。

C#
public class Circle
{
    private double radius;

    public double Radius
    {
        get { return radius; }
        set
        {
            if (value > 0)
            {
                radius = value; // 仅当值合法时才设置
            }
            else
            {
                throw new ArgumentException("半径必须大于零。"); // 否则抛出异常
            }
        }
    }
}

示例：

C#
internal class Program
{
    static void Main(string[] args)
    {
        try
        {
            Circle circle = new Circle();
            circle.Radius = -5; // 尝试设置非法值
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

输出：

---

方法（Method）

方法定义了类的行为，封装了执行特定操作的代码逻辑。方法可以接受参数、执行运算并返回结果。

方法的基本使用

C#
public class Calculator
{
    // 加法方法，接受两个整数参数并返回它们的和
    public int Add(int a, int b)
    {
        return a + b;
    }
}

示例：

C#
internal class Program
{
    static void Main(string[] args)
    {
        Calculator calculator = new Calculator();
        int sum = calculator.Add(3, 5);
        Console.WriteLine($"3 + 5 = {sum}");
    }
}

输出：

带有多个方法的类

C#
public class MathOperations
{
    // 乘法方法
    public int Multiply(int a, int b)
    {
        return a * b;
    }

    // 除法方法
    public double Divide(double a, double b)
    {
        if (b == 0)
        {
            throw new DivideByZeroException("除数不能为零。");
        }
        return a / b;
    }
}

示例：

C#
internal class Program
{
    static void Main(string[] args)
    {
        MathOperations mathOps = new MathOperations();
        int product = mathOps.Multiply(4, 6);
        Console.WriteLine($"4 * 6 = {product}");

        try
        {
            double quotient = mathOps.Divide(10, 0);
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

输出：

方法的重载

方法重载允许在同一类中创建多个同名方法，但参数列表必须不同。

C#
public class Logger
{
    // 日志方法：记录字符串消息
    public void Log(string message)
    {
        Console.WriteLine($"Message: {message}");
    }

    // 日志方法：记录异常信息
    public void Log(Exception ex)
    {
        Console.WriteLine($"Exception: {ex.Message}");
    }
}

示例：

C#
internal class Program
{
    static void Main(string[] args)
    {
        Logger logger = new Logger();
        logger.Log("This is a simple message.");

        try
        {
            int y = 0;
            int result = 10 / y;
        }
        catch (Exception ex)
        {
            logger.Log(ex);
        }
    }
}

输出：

静态方法与实例方法

• 实例方法：必须通过对象实例调用，方法内部可以访问实例成员。
• 静态方法：通过类名调用，不需要创建实例，不能访问实例成员。

静态方法示例：

C#
public class Utility
{
    public static void DisplayTime()
    {
        Console.WriteLine($"Current Time: {DateTime.Now}");
    }
}

示例：

C#
internal class Program
{
    static void Main(string[] args)
    {
        Utility.DisplayTime();
    }
}

输出：

---

属性与方法的综合应用

C#
public class BankAccount
{
    private decimal balance;

    public string AccountNumber { get; } // 只读属性
    public string Owner { get; set; } // 自动属性

    public decimal Balance
    {
        get { return balance; }
        private set { balance = value; } // 私有设置器，只能在类内部修改
    }

    public BankAccount(string owner, decimal initialBalance)
    {
        AccountNumber = Guid.NewGuid().ToString();
        Owner = owner;
        Balance = initialBalance;
    }

    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            Balance += amount;
            Console.WriteLine($"已存入：{amount:C2}");
        }
        else
        {
            Console.WriteLine("存款金额必须大于零。");
        }
    }

    public void Withdraw(decimal amount)
    {
        if (amount > 0 && amount <= Balance)
        {
            Balance -= amount;
            Console.WriteLine($"已取出：{amount:C2}");
        }
        else
        {
            Console.WriteLine("取款金额无效或余额不足。");
        }
    }
}

示例：

C#
internal class Program
{
    static void Main(string[] args)
    {
        BankAccount account = new BankAccount("Charlie", 1000m);
        Console.WriteLine($"账户所有者：{account.Owner}");
        Console.WriteLine($"账户余额：{account.Balance:C2}");

        account.Deposit(500m);
        Console.WriteLine($"账户余额：{account.Balance:C2}");

        account.Withdraw(200m);
        Console.WriteLine($"账户余额：{account.Balance:C2}");

        account.Withdraw(1500m); // 尝试取出超过余额的金额
    }
}

输出：

---

在实际编程中的应用场景

• 数据封装和保护：通过属性控制对私有字段的访问，确保数据的完整性。
• 数据验证：在属性设置器中添加验证逻辑，防止无效数据。
• 行为实现：使用方法实现类的功能，如计算、数据处理和与外部系统的交互。
• 代码重用和维护：合理的属性和方法设计提高了代码的可重用性和可维护性。

---

注意事项

• 属性设计：
  • 使用属性封装私有字段，提供必要的访问控制。
  • 在设置器中进行数据验证，确保对象状态的有效性。
  • 考虑使用只读或只写属性满足特殊需求。
• 方法设计：
  • 方法应具有明确的职责，避免过于复杂。
  • 使用方法重载提高代码的灵活性。
  • 适当使用静态方法，提供与实例无关的功能。

总结

通过本文的详细介绍，我们深入了解了C#中属性和方法的使用方式。属性使得我们可以优雅地控制对类内部数据的访问和修改，并确保数据的有效性。方法则定义了类的行为，承担了执行操作和业务逻辑的职责。

在编写代码时，应遵循以下原则：