VB.NET - 滥用实例变量？

Question

请看下面的代码:

    Public Class A
    Public person1 As Person
End Class

Public Class B
    Inherits A

    Public Function CheckGender() As Boolean
        If person1._Gender = "M" Then
            CheckGender = True
        End If
    End Function

End Class

Public Class C
    Inherits B
    Public Function CheckAge() As Boolean
        If person1._Age > 30 Then
            CheckAge = True
        End If
    End Function

End Class

Public Class D
    Inherits C

    Public Sub SomeMethod()
        Dim list As List(Of Person) = New List(Of Person)
        Dim p1 As New Person("Ian", "M", 31)
        Dim p2 As New Person("Susan", "F", 20)
        Dim p3 As New Person("Mark", "M", 22)
        list.Add(p1)
        list.Add(p2)
        list.Add(p3)

        For Each Person As Person In list
            person1 = Person
            If CheckAge() And CheckGender() Then
                'Do something
            End If
        Next
    End Sub

    Public Shared Sub Main()
        Dim d As New D
        d.SomeMethod()
    End Sub

End Class

Public Class Person
    Public _Name As String
    Public _Gender As String
    Public _Age As String
    Public Sub New(ByVal Name As String, ByVal Gender As String, ByVal Age As Integer)
        _Name = Name
        _Gender = Gender
        _Age = Age
    End Sub
End Class

c.SomeMethod 循环遍历三个人并执行两项检查:b.CheckGender 和 c.CheckAge。 CheckGender 和 CheckAge 使用父类(super class) A 中的实例变量。

实时环境中的代码每天循环遍历数据库中的 100,000 条记录，并删除 CheckGender 和 CheckAge 均为 true 的记录。 在这种情况下使用实例变量是一个糟糕的设计选择吗？我总是被教导要使用局部变量。我希望在每个循环上将 Person 对象传递给 CheckGender 和 CheckAge 。还是真的不重要？

请注意，上面的代码是一个假设的示例。 CheckGender和CheckAge在实际应用中是复杂的函数。

Answer 1

只要CheckGender和CheckAge不访问层次结构中类的任何私有(private)、 protected 或内部成员，并且是公共(public)函数，它们的逻辑是相同的对于任何实例，无论是 A、B 或 C，将这些方法放在另一个类中都是更好的设计。如果可能的话，使它们静态。您可以让他们接受您的类的最通用的实现(例如 A)，该实现允许检查年龄或性别。根据您的代码，您甚至可以传递 Person 属性，而不是使用 A、B 和 C 中的任何一个> 类(class)。

在上述情况下使用继承和此类逻辑是允许的，只要您需要执行以下任何或全部操作:

• 符合 A、B 和 C 类必须实现的特定接口(interface)或基类/extend，并且该接口(interface)或基类提供 CheckGender 和 CheckAge 方法。如果您将对象传递给第 3 方 API，该 API 接受基类/接口(interface)作为参数并在内部调用检查方法，这可能是唯一的解决方案。

这是 C# 中的示例:

public static class CheckUtil
{
    public static bool CheckAgeOfPerson(Person p)
    {
        return p.Age > 30;
    }
    public static bool CheckAgeOfObject(A obj)
    {
        // NOTE: obj.person1 must be accessible - by being either public or internal.
        // If this class is in another assembly, internal is not useful
        return CheckAgeOfPerson(obj.person1);
    }
}

A objA = ...;
B objB = ...;
C objC = ...;

CheckUtil.CheckAgeOfObject(objA);
CheckUtil.CheckAgeOfObject(objB);
CheckUtil.CheckAgeOfObject(objC);

CheckUtil.CheckAgeOfPerson(objA.person1);
CheckUtil.CheckAgeOfPerson(objB.person1);
CheckUtil.CheckAgeOfPerson(objC.person1);

• 为类提供具体实现。如果您必须在 CheckAge 中对 A 的实例进行一些逻辑，但对 B 的实例进行完全不同的验证，或者现有的组合以及 C 中的一些新逻辑，那么继承就是你的 friend 。不过，如果是这种情况，我更愿意将 CheckGender 和 CheckAge 公开给接口(interface)并通过接口(interface)调用它们。这样，只要满足接口(interface)，继承就是有效的，但不是强制性的。

这是一个 C# 示例:

public interface IGenderCheckable
{
    bool CheckGender();
}

public interface IAgeCheckable
{
    bool CheckAge();
}

public class A : IAgeCheckable, IGenderCheckable
{
    public virtual bool CheckGender()
    {
        return this.person1.Gender.Equals("M");
    }

    public virtual bool CheckAge()
    {
        return this.person1.Age > 30;
    }
}

public class B : A
{
     public override bool CheckAge()
     {
          // combine custom logic with new logic
          return this.person1.Age < 0 || base.CheckAge();
     }
}

对于复杂的场景，也可以使用两种方法的组合(当然对于比年龄和性别检查复杂得多的情况):

public class A : IAgeCheckable, IGenderCheckable
{
    ...
}

public static class CheckUtil
{
    public static bool CheckAge(IAgeCheckable obj)
    {
        return obj.CheckAge();
    }
    public static bool CheckGender(IGenderCheckable)
    {
        return obj.CheckGender();
    }
}

<小时/>

关于实例变量与局部变量的使用 - 在 .NET 中使用实例变量的性能存在缺陷，特别是当它们是值类型时。例如，使用 int _someIntMember 本地成员会被转换为 this._someIntMember - 进而调用堆来获取 this 对象，然后访问其 _someIntMember 成员。将成员作为局部变量，将其值放入堆栈中，并从那里读取它，而无需在堆中进行不必要的往返。而且，栈比堆更快。

但是，我不能说过多的堆使用是否是对它的滥用，也不能说过多使用局部变量是否是对它们的滥用。这取决于所需的性能以及代码的复杂性。有时局部变量使代码更具可读性，但如果太多，您可能很容易忘记每个变量是什么(这可能是比疏忽的性能增益更严重的问题)。所以这是一个风格和必要性的问题。