MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Visual Basic属性访问器与索引器设计

2021-08-062.6k 阅读

Visual Basic 属性访问器基础

在 Visual Basic 编程中，属性（Property）是一种特殊的成员，它为对象的字段提供了一种灵活的访问机制。属性通过属性访问器（Property Accessors）来实现对字段值的读取（get 访问器）和写入（set 访问器）操作。

属性访问器允许程序员控制如何获取和设置对象的状态。与直接访问字段相比，属性提供了更高层次的抽象和封装。例如，考虑一个表示人的类 Person，其中有一个表示年龄的字段 _age。如果直接公开这个字段，外部代码可以随意修改它，可能导致不符合业务逻辑的值被设置。而通过属性，我们可以在属性访问器中添加验证逻辑。

以下是一个简单的示例：

Public Class Person
    Private _age As Integer
    Public Property Age As Integer
        Get
            Return _age
        End Get
        Set(value As Integer)
            If value >= 0 AndAlso value <= 120 Then
                _age = value
            Else
                Throw New ArgumentOutOfRangeException("年龄必须在 0 到 120 之间")
            End If
        End Set
    End Property
End Class

在上述代码中，Age 属性有一个 Get 访问器，用于返回 _age 字段的值。Set 访问器接收一个参数 value，并在设置 _age 之前验证 value 是否在合理范围内。

只读和只写属性

在 Visual Basic 中，可以创建只读（Read - Only）或只写（Write - Only）属性。只读属性只有 Get 访问器，意味着只能获取属性值，不能设置。只写属性只有 Set 访问器，只能设置属性值，不能获取。

只读属性示例：

Public Class Circle
    Private _radius As Double
    Public Sub New(radius As Double)
        _radius = radius
    End Sub
    Public ReadOnly Property Area As Double
        Get
            Return Math.PI * _radius * _radius
        End Get
    End Property
End Class

在 Circle 类中，Area 属性是只读的。它根据 _radius 字段计算圆的面积，外部代码只能获取该属性值，无法修改。

只写属性示例：

Public Class SecretData
    Private _secret As String
    Public WriteOnly Property SecretValue As String
        Set(value As String)
            If String.IsNullOrEmpty(value) Then
                Throw New ArgumentException("秘密值不能为空")
            End If
            _secret = value
        End Set
    End Property
End Class

在 SecretData 类中，SecretValue 属性是只写的。它确保设置的秘密值不为空，外部代码无法直接获取该秘密值。

Visual Basic 索引器基础

索引器（Indexer）允许对象像数组一样通过索引进行访问。它为对象提供了一种基于索引的属性访问方式，在处理集合类或需要通过索引访问元素的场景中非常有用。

索引器的声明

在 Visual Basic 中，声明索引器需要使用 Default 关键字。以下是一个简单的示例，假设有一个表示学生成绩的类 StudentGrades，我们希望通过索引来访问学生的成绩。

Public Class StudentGrades
    Private grades() As Double
    Public Sub New(numberOfStudents As Integer)
        ReDim grades(numberOfStudents - 1)
    End Sub
    Default Public Property Item(index As Integer) As Double
        Get
            If index < 0 OrElse index >= grades.Length Then
                Throw New IndexOutOfRangeException()
            End If
            Return grades(index)
        End Get
        Set(value As Double)
            If index < 0 OrElse index >= grades.Length Then
                Throw New IndexOutOfRangeException()
            End If
            grades(index) = value
        End Set
    End Property
End Class

在上述代码中，StudentGrades 类有一个索引器 Item。当声明索引器时使用 Default 关键字，意味着可以通过对象名直接使用索引访问，而不需要指定属性名。例如：

Dim studentGrades As New StudentGrades(5)
studentGrades(0) = 85
Dim grade As Double = studentGrades(0)

多参数索引器

索引器并不局限于单个参数。在某些情况下，可能需要多个参数来唯一标识要访问的元素。例如，假设有一个二维数组表示棋盘，我们可以使用双参数索引器来访问棋盘上的位置。

Public Class ChessBoard
    Private board(,) As String
    Public Sub New(width As Integer, height As Integer)
        ReDim board(width - 1, height - 1)
    End Sub
    Default Public Property Item(x As Integer, y As Integer) As String
        Get
            If x < 0 OrElse x >= board.GetLength(0) OrElse y < 0 OrElse y >= board.GetLength(1) Then
                Throw New IndexOutOfRangeException()
            End If
            Return board(x, y)
        End Get
        Set(value As String)
            If x < 0 OrElse x >= board.GetLength(0) OrElse y < 0 OrElse y >= board.GetLength(1) Then
                Throw New IndexOutOfRangeException()
            End If
            board(x, y) = value
        End Set
    End Property
End Class

在 ChessBoard 类中，索引器 Item 接受两个整数参数 x 和 y，用于定位棋盘上的特定位置。使用示例如下：

Dim chessBoard As New ChessBoard(8, 8)
chessBoard(3, 4) = "车"
Dim piece As String = chessBoard(3, 4)

属性访问器与索引器的高级设计

属性访问器中的数据验证与转换

在实际应用中，属性访问器不仅用于简单的字段读取和写入，还可以进行复杂的数据验证和转换。例如，假设我们有一个表示日期的类 MyDate，其中有一个属性 DateValue 表示日期。我们希望在设置日期时进行格式验证和转换。

Public Class MyDate
    Private _dateValue As DateTime
    Public Property DateValue As String
        Get
            Return _dateValue.ToString("yyyy - MM - dd")
        End Get
        Set(value As String)
            Dim tempDate As DateTime
            If DateTime.TryParseExact(value, "yyyy - MM - dd", CultureInfo.InvariantCulture, DateTimeStyles.None, tempDate) Then
                _dateValue = tempDate
            Else
                Throw New FormatException("日期格式不正确，必须为 yyyy - MM - dd")
            End If
        End Set
    End Property
End Class

在上述代码中，DateValue 属性的 Get 访问器将 _dateValue 字段格式化为 "yyyy - MM - dd" 的字符串形式返回。Set 访问器尝试将传入的字符串解析为 DateTime 类型，如果解析成功则设置 _dateValue，否则抛出异常。

索引器的性能优化

在设计索引器时，尤其是在处理大型集合时，性能是一个关键问题。例如，对于一个包含大量元素的自定义集合类，使用线性查找的索引器可能会导致性能瓶颈。考虑以下场景，我们有一个自定义的员工集合类 EmployeeCollection，希望通过员工 ID 来快速定位员工。

Imports System.Collections.Generic

Public Class Employee
    Public Property EmployeeId As Integer
    Public Property Name As String
End Class

Public Class EmployeeCollection
    Private employees As Dictionary(Of Integer, Employee)
    Public Sub New()
        employees = New Dictionary(Of Integer, Employee)
    End Sub
    Default Public Property Item(employeeId As Integer) As Employee
        Get
            Dim employee As Employee
            If employees.TryGetValue(employeeId, employee) Then
                Return employee
            Else
                Throw New KeyNotFoundException()
            End If
        End Get
        Set(value As Employee)
            If value IsNot Nothing Then
                employees(employeeId) = value
            End If
        End Set
    End Property
End Class

在 EmployeeCollection 类中，我们使用 Dictionary(Of Integer, Employee) 来存储员工信息。索引器通过 Dictionary 的 TryGetValue 方法快速定位员工，相比线性查找大大提高了性能。

结合属性访问器和索引器实现复杂功能

在一些复杂的对象模型中，可能需要结合属性访问器和索引器来实现特定的功能。例如，假设有一个表示电子表格的类 Spreadsheet，其中每个单元格可以通过行列索引访问，并且每个单元格有一些属性，如值、格式等。

Public Class Cell
    Private _value As Object
    Private _format As String
    Public Property Value As Object
        Get
            Return _value
        End Get
        Set(value As Object)
            _value = value
        End Set
    End Property
    Public Property Format As String
        Get
            Return _format
        End Get
        Set(value As String)
            _format = value
        End Set
    End Property
End Class

Public Class Spreadsheet
    Private cells(,) As Cell
    Public Sub New(rows As Integer, cols As Integer)
        ReDim cells(rows - 1, cols - 1)
        For i As Integer = 0 To rows - 1
            For j As Integer = 0 To cols - 1
                cells(i, j) = New Cell()
            Next
        Next
    End Sub
    Default Public Property Item(row As Integer, col As Integer) As Cell
        Get
            If row < 0 OrElse row >= cells.GetLength(0) OrElse col < 0 OrElse col >= cells.GetLength(1) Then
                Throw New IndexOutOfRangeException()
            End If
            Return cells(row, col)
        End Get
        Set(value As Cell)
            If row < 0 OrElse row >= cells.GetLength(0) OrElse col < 0 OrElse col >= cells.GetLength(1) Then
                Throw New IndexOutOfRangeException()
            End If
            cells(row, col) = value
        End Set
    End Property
End Class

在上述代码中，Spreadsheet 类有一个双参数索引器 Item，用于访问特定行列的 Cell 对象。而 Cell 类有 Value 和 Format 两个属性，通过属性访问器来操作单元格的具体数据和格式。使用示例如下：

Dim spreadsheet As New Spreadsheet(10, 10)
Dim cell As Cell = spreadsheet(3, 4)
cell.Value = 100
cell.Format = "N2"

基于属性访问器和索引器的设计模式应用

代理模式与属性访问器

代理模式（Proxy Pattern）可以通过属性访问器来实现。代理模式为其他对象提供一种代理以控制对这个对象的访问。例如，假设我们有一个数据库连接类 DatabaseConnection，在实际使用中，我们可能希望在访问数据库连接时进行一些额外的操作，如日志记录、权限验证等。我们可以创建一个代理类 DatabaseConnectionProxy。

Public Class DatabaseConnection
    Public Sub Connect()
        Console.WriteLine("连接到数据库")
    End Sub
    Public Sub Disconnect()
        Console.WriteLine("断开与数据库的连接")
    End Sub
End Class

Public Class DatabaseConnectionProxy
    Private realConnection As DatabaseConnection
    Private loggedInUser As String
    Public Sub New(user As String)
        loggedInUser = user
        realConnection = New DatabaseConnection()
    End Sub
    Public Property Connection As DatabaseConnection
        Get
            If loggedInUser = "admin" Then
                Return realConnection
            Else
                Throw New UnauthorizedAccessException("只有管理员可以访问数据库连接")
            End If
        End Get
        Set(value As DatabaseConnection)
            realConnection = value
        End Set
    End Property
End Class

在 DatabaseConnectionProxy 类中，Connection 属性的 Get 访问器在返回实际的数据库连接对象之前，先验证当前用户是否为管理员。如果是，则返回连接对象，否则抛出异常。

迭代器模式与索引器

迭代器模式（Iterator Pattern）用于提供一种方法顺序访问一个聚合对象中各个元素，而又不需要暴露该对象的内部表示。虽然 Visual Basic 有内置的迭代器支持，但我们可以通过索引器来模拟简单的迭代器功能。例如，假设有一个自定义的链表类 MyLinkedList，我们可以通过索引器来实现类似于迭代器的功能。

Public Class Node
    Public Property Value As Integer
    Public Property NextNode As Node
    Public Sub New(value As Integer)
        Me.Value = value
    End Sub
End Class

Public Class MyLinkedList
    Private head As Node
    Public Sub Add(value As Integer)
        Dim newNode As New Node(value)
        If head Is Nothing Then
            head = newNode
        Else
            Dim current As Node = head
            While current.NextNode IsNot Nothing
                current = current.NextNode
            End While
            current.NextNode = newNode
        End If
    End Sub
    Default Public Property Item(index As Integer) As Integer
        Get
            Dim current As Node = head
            Dim count As Integer = 0
            While current IsNot Nothing
                If count = index Then
                    Return current.Value
                End If
                count += 1
                current = current.NextNode
            End While
            Throw New IndexOutOfRangeException()
        End Get
    End Property
End Class

在 MyLinkedList 类中，通过索引器 Item 可以按索引访问链表中的节点值。虽然这不是一个完整的迭代器实现，但在一定程度上模拟了迭代器的功能。使用示例如下：

Dim linkedList As New MyLinkedList()
linkedList.Add(10)
linkedList.Add(20)
Dim value As Integer = linkedList(1)

与其他语言的对比

与 C# 的对比

在 C# 中，属性访问器的语法与 Visual Basic 有一些相似之处，但也存在差异。例如，在 C# 中，属性的声明方式如下：

public class Person
{
    private int _age;
    public int Age
    {
        get { return _age; }
        set
        {
            if (value >= 0 && value <= 120)
            {
                _age = value;
            }
            else
            {
                throw new ArgumentOutOfRangeException("年龄必须在 0 到 120 之间");
            }
        }
    }
}

可以看到，C# 的属性访问器使用花括号来包裹 get 和 set 块，而 Visual Basic 使用 Get 和 Set 关键字，并以 End Get 和 End Set 结束。

对于索引器，C# 的语法也有所不同。在 C# 中，索引器声明如下：

public class StudentGrades
{
    private double[] grades;
    public StudentGrades(int numberOfStudents)
    {
        grades = new double[numberOfStudents];
    }
    public double this[int index]
    {
        get
        {
            if (index < 0 || index >= grades.Length)
            {
                throw new IndexOutOfRangeException();
            }
            return grades[index];
        }
        set
        {
            if (index < 0 || index >= grades.Length)
            {
                throw new IndexOutOfRangeException();
            }
            grades[index] = value;
        }
    }
}

C# 使用 this 关键字来表示索引器，而 Visual Basic 使用 Default 关键字和 Item 属性名（可以省略 Item）。

与 Java 的对比

Java 中没有直接类似于 Visual Basic 属性访问器的概念。在 Java 中，通常通过 getter 和 setter 方法来实现类似的功能。例如：

public class Person {
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age >= 0 && age <= 120) {
            this.age = age;
        } else {
            throw new IllegalArgumentException("年龄必须在 0 到 120 之间");
        }
    }
}

在 Java 中，也没有索引器的概念。如果要实现类似通过索引访问元素的功能，通常会使用数组或实现 List 等接口。例如：

import java.util.ArrayList;
import java.util.List;

public class StudentGrades {
    private List<Double> grades = new ArrayList<>();
    public StudentGrades(int numberOfStudents) {
        for (int i = 0; i < numberOfStudents; i++) {
            grades.add(0.0);
        }
    }
    public double getGrade(int index) {
        if (index < 0 || index >= grades.size()) {
            throw new IndexOutOfBoundsException();
        }
        return grades.get(index);
    }
    public void setGrade(int index, double grade) {
        if (index < 0 || index >= grades.size()) {
            throw new IndexOutOfBoundsException();
        }
        grades.set(index, grade);
    }
}

通过对比可以看出，Visual Basic 的属性访问器和索引器为开发者提供了一种更简洁、直观的方式来控制对象数据的访问和集合元素的索引访问，与其他语言在实现方式上存在明显差异。

最佳实践与常见问题

最佳实践

  1. 保持属性访问器简洁：属性访问器应该只负责简单的读取和写入操作以及必要的验证。避免在属性访问器中包含复杂的业务逻辑，复杂逻辑应封装在单独的方法中。例如，在 Person 类的 Age 属性中，只进行年龄范围的验证，而不要在其中包含计算与年龄相关的复杂业务规则。
  2. 合理使用索引器：在设计索引器时，确保索引器的参数有明确的语义，并且能够高效地定位元素。对于大型集合，应采用合适的数据结构（如哈希表、二叉树等）来提高索引器的性能，如前面 EmployeeCollection 类使用 Dictionary 来存储员工信息。
  3. 文档化属性和索引器：为属性和索引器添加详细的文档注释，说明其用途、参数含义、返回值以及可能抛出的异常。这有助于其他开发者理解和使用你的代码。例如，可以使用 Visual Basic 的 XML 注释语法为 StudentGrades 类的索引器添加注释：
''' <summary>
''' 获取或设置指定索引位置的学生成绩。
''' </summary>
''' <param name="index">学生的索引，从 0 开始。</param>
''' <returns>指定索引位置的学生成绩。</returns>
''' <exception cref="IndexOutOfRangeException">当索引超出有效范围时抛出。</exception>
Default Public Property Item(index As Integer) As Double
    Get
        If index < 0 OrElse index >= grades.Length Then
            Throw New IndexOutOfRangeException()
        End If
        Return grades(index)
    End Get
    Set(value As Double)
        If index < 0 OrElse index >= grades.Length Then
            Throw New IndexOutOfRangeException()
        End If
        grades(index) = value
    End Set
End Property

常见问题

  1. 无限递归问题：在属性访问器中，如果不小心在 Get 访问器中调用 Set 访问器，或者在 Set 访问器中调用 Get 访问器，可能会导致无限递归，最终导致栈溢出错误。例如：
Public Class BadProperty
    Private _value As Integer
    Public Property MyValue As Integer
        Get
            MyValue = _value + 1 '错误：在 Get 中设置 MyValue，导致无限递归
            Return _value
        End Get
        Set(value As Integer)
            _value = value
        End Set
    End Property
End Class

要避免这种情况，确保在属性访问器中只进行合理的读取和写入操作，不要在 Get 中设置属性值，除非有特殊的设计需求并且经过仔细考虑。 2. 索引器参数验证不充分：如果在索引器中没有对传入的索引参数进行充分的验证，可能会导致运行时异常。例如，在前面的 StudentGrades 类中，如果没有对 index 参数进行范围检查，当外部代码传入一个无效的索引时，可能会导致数组越界异常。因此，在索引器的 Get 和 Set 访问器中都要进行严格的参数验证。 3. 属性访问器性能问题：如果在属性访问器中执行了大量的计算或 I/O 操作，可能会影响性能。例如，在属性的 Get 访问器中每次都从数据库读取数据，而不是缓存数据，会导致性能下降。在这种情况下，可以考虑在对象初始化时读取数据并缓存，或者使用懒加载机制，在第一次访问属性时读取并缓存数据。

通过遵循最佳实践并注意常见问题，可以设计出高效、健壮且易于维护的 Visual Basic 属性访问器和索引器。在实际编程中，根据具体的业务需求和场景，灵活运用属性访问器和索引器的特性，能够提升代码的质量和可维护性。