Introduction
This article describes a simple approach to downcasting in Visual Basic; downcasting merely refers to the process of casting an object of a base class type to a derived class type. Upcasting is legal in Visual Basic as the process there is to convert an object of a derived class type into an object of its base class type. In spite of the general illegality of downcasting you may find that when working with generics it is sometimes handy to do it anyway.
Figure 1: Test Application in Use
The Solution
The example solution provided is in the form of a Windows form application. The application contains a single form along with three separate classes. The Person class serves as the base class in this example and Lawyer is derived from the Person class. The "PeopleHandler" class offers a single method used to save objects of either the Person or the Lawyer class.
Figure 2: The demonstration project
The Code: Person Class
The project contains two classes used to provide an example of a base class and a derived class. They are the person class (the base) and the lawyer class (derived from person). The person class contains some basic information about a person whilst the lawyer class inherits from the person class and contains a couple of additional properties: The two classes serve no purpose other than to give us an example base and derived class.
Public Class Person
Private mFirstName As String
Private mMiddleName As String
Private mLastName As String
Private mAge As Integer
Public Property FirstName() As String
Get
Return mFirstName
End Get
Set(ByVal value As String)
mFirstName = value
End Set
End Property
Public Property MiddleName() As String
Get
Return mMiddleName
End Get
Set(ByVal value As String)
mMiddleName = value
End Set
End Property
Public Property LastName() As String
Get
Return mLastName
End Get
Set(ByVal value As String)
mLastName = value
End Set
End Property
Public Property Age() As Integer
Get
Return mAge
End Get
Set(ByVal value As Integer)
mAge = value
End Set
End Property
End Class
The Code: Lawyer Class
The lawyer class inherits from Person and adds a couple of additional properties appropriate for lawyers:
Public Class Lawyer
Inherits Person
Private mNumberOfClientsShafted As Integer
Private mNumberOfLiesTold As Integer
''' <summary>
''' This should probably be a long
''' </summary>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Public Property NumberOfClientsShafted() As Integer
Get
Return mNumberOfClientsShafted
End Get
Set(ByVal value As Integer)
mNumberOfClientsShafted = value
End Set
End Property
''' <summary>
''' This ought to be a long too
''' </summary>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Public Property NumberOfLiesTold() As Integer
Get
Return mNumberOfLiesTold
End Get
Set(ByVal value As Integer)
mNumberOfLiesTold = value
End Set
End Property
End Class
The Code: Lawyer Class
What now makes this all interesting is if we wanted to use a single method to save either a person or a lawyer (I'm going out on a limb here in indicating that lawyers inherit from persons). To illustrate the point, I built a separate class entitled, "PeopleHandler". The sole method contained in this class can accept either a person or one of person's derived class which is in this case only lawyers. Now, if we pass the following method an object of the person type, everything is fine and all properties are visible in the code. However, if we pass in object of the lawyer type (the derived class), the object is treated as a person rather than a lawyer and the other lawyer properties are invisible to the code even though the lawyer object passed to the "SavePerson" method contains both properties. Since downcasting is not permitted, it is necessary to cast the lawyer as a lawyer rather than as a person; unfortunately, that does not work.
If you tried this: "DirectCast(pers, Lawyer)", the code would show an error indicating that one cannot cast T as a lawyer. Well, in this case, we know full well that "pers" is really a lawyer and not a person so it would be really helpful if we could use it as a lawyer rather than as a person.
In the following bit of code (highlighted) you can see a solution to the dilemma and it is pretty easy, just convert the lawyer to an object and then cast is over to lawyer; that works. After doing that, you will find that you can access the additional properties of the lawyer without difficulty. To avoid any problems with that, I get the type of object passed into the method and use a switch statement to limit my attempts to read lawyer properties to lawyer objects only. You may prefer to use TryCast to DirectCast and provide additional code to handle a TryCast failure.
The code that I used is provided in the following:
Imports System.Collections.Generic
Imports System.Text
Public Class PeopleHandler
Public Shared Function SavePerson(Of T)(ByVal pers As Person) As String
Try
Dim sb As New StringBuilder()
Dim tPers As Type = pers.GetType()
Dim arr As String() = tPers.ToString().Split(".")
Dim personType As String = arr(arr.Length - 1)
Dim mAge As Integer = pers.Age
Dim mFirstName As String = pers.FirstName
Dim mMiddleName As String = pers.MiddleName
Dim mLastName As String = pers.LastName
Select Case personType
Case "Person"
sb.Append("Save Type: " + personType &
Environment.NewLine)
sb.Append("Name: " + mFirstName + " " + mMiddleName + " "
+ mLastName & Environment.NewLine)
sb.Append("Age: " + mAge.ToString() &
Environment.NewLine)
Case "Lawyer"
sb.Append("Save Type: " + personType &
Environment.NewLine)
sb.Append("Name: " + mFirstName + " " + mMiddleName + " "
+ mLastName & Environment.NewLine)
sb.Append("Age: " + mAge.ToString() &
Environment.NewLine)
sb.Append("Number of Clients Shafted: " + _
DirectCast(DirectCast(pers, Object),
Lawyer).NumberOfClientsShafted.ToString() & _
Environment.NewLine)
sb.Append("Number of Lies Told: " + _
DirectCast(DirectCast(pers, Object),
Lawyer).NumberOfLiesTold.ToString() & _
Environment.NewLine)
Case Else
sb.Append("Nothing there")
End Select
Return sb.ToString()
Catch ex As Exception
Return ex.Message
End Try
End Function
End Class
The Form1 Class
The form1 class itself is used to test the People Handler's "SavePerson" method by passing it an object of type person and an object of type lawyer. The results of running the executable will display information about both the person and lawyer objects passed to the method.
public class Program
{
static void Main(string[] args)
{
Person MacDuff = new Person();
MacDuff.Age = 44;
MacDuff.FirstName = "Alexander";
MacDuff.MiddleName = "Hercules";
MacDuff.LastName = "MacDuff";
PeopleHandler.SavePerson(MacDuff);
Console.WriteLine(Environment.NewLine);
Lawyer creep = new Lawyer();
creep.FirstName = "Gordon";
creep.MiddleName = "Bud";
creep.LastName = "Miller";
creep.Age = 50;
creep.NumberOfLiesTold = 100000;
creep.NumberOfPeopleShafted = 5000;
PeopleHandler.SavePerson(creep);
Console.Read();
}
}
Summary
This example provided an approach to downcasting; the article provides an example showing how downcasting might be useful when saving base and derived class objects using a common save method.