Visual Basic provides a simple syntax for initializing an object's properties as you create it. Create the object as usual with a New statement. Next add the keyword With and a pair of braces holding the property assignments. Each assignment should include a dot, a property name, an equals sign, and the value you want to give to the property.

For example, the following code creates an Employee object named Bob. The statements inside the braces initialize the object's properties.

' Make an Employee named Bob.
Dim bob As New Employee() With
{
    .FirstName = "Bob",
    .LastName = "Baker",
    .Street = "200 Beach Blvd",
    .City = "Bugsville",
    .State = "CO",
    .Zip = "82010",
    .EmployeeId = 1002,
    .MailStop = "B-2"
}

Initializers are handy and easy to use but sometimes you might like some extra control over how an object is created. Constructors give you that extra control.

A constructor is a subroutine named New that is executed when an object is created. The constructor executes before the code that creates the object gets hold of it. The constructor can perform any setup tasks that you want to get the object ready for use. It can look up data in databases, prepare data structures, and initialize properties.

The next two sections describe two kinds of constructors: parameterless constructors and parameterized constructors. The section after those explains how one constructor can invoke another to avoid duplicated work.

Public Class Manager
    Inherits Employee

    Public Property DirectReports As List(Of Employee)

    ' Initialize the DirectReports list.
    Public Sub New()
        DirectReports = New List(Of Employee)()
    End Sub
End Class

Dim fred As New Manager()

Dim cindy As New Person("Cindy", "Carstairs",
    "300 Clam Ct", "Bugsville", "CO", "82010")

' Initializing constructor.
Public Sub New(ByVal newFirstName As String,
 ByVal newLastName As String, ByVal newStreet As String,
 ByVal newCity As String, ByVal newState As String,
 ByVal newZip As String)

    ' Verify that FirstName and LastName are present.
    If newFirstName Is Nothing Then
        Throw New ArgumentException("FirstName is required")
    End If
    If newFirstName.Length = 0 Then
        Throw New ArgumentException("FirstName cannot be blank")
    End If
    If newLastName Is Nothing Then
        Throw New ArgumentException("LastName is required")
    End If
    If newLastName.Length = 0 Then
        Throw New ArgumentException("LastName cannot be blank")
    End If

    ' Initialize the properties.
    FirstName = newFirstName
    LastName = newLastName
    Street = newStreet
    City = newCity
    State = newState
    Zip = newZip
End Sub

You can give a class many different constructors as long as they have different parameter lists (so Visual Basic can tell them apart). For example, you might give the Person class a parameterless constructor; a second constructor that takes first name and last name as parameters; and a third constructor that takes first name and last name, street, city, state, and zip code as parameters.

Often when you give a class multiple constructors, some of them perform the same actions. In the Person example, the constructor that initializes first name, last name, street, city, state, and zip code probably does the same things that the second constructor does to initialize just first name and last name (plus more).

You can also find overlapping constructor functionality when one class inherits from another. For example, suppose the Person class has FirstName and LastName properties. The Employee class inherits from Person and adds some other properties such as EmployeeId and MailStop. The Person class's constructor initializes the FirstName and LastName properties, something that the Employee class's constructors should also do.

Having several methods perform the same tasks makes debugging and maintaining code harder. Fortunately, Visual Basic provides a way you can make one constructor invoke another.

To make a constructor use another constructor in the same class, simply invoke it as if it were any other subroutine. The only catch is that you need to call the constructor Me.New, not just New.

For example, the following code shows three constructors for the Person class that invoke each other. The code that invokes other constructors is shown in bold.

' Parameterless constructor.
Public Sub New()
    ' General initialization if needed...
End Sub

' Initialize FirstName and LastName only.
Public Sub New(ByVal newFirstName As String, ByVal newLastName As String)
    ' Call the parameterless constructor.
    Me.New()

    ' Initialize the properties.
    FirstName = newFirstName
    LastName = newLastName
End Sub

' Initialize all properties.
Public Sub New(ByVal newFirstName As String, ByVal newLastName As String,
 ByVal newStreet As String, ByVal newCity As String,
 ByVal newState As String, ByVal newZip As String)
    ' Call the previous constructor to initialize FirstName and LastName.
    Me.New(newFirstName, newLastName)

    ' Initialize the other properties.
    Street = newStreet
    City = newCity
    State = newState
    Zip = newZip
End Sub

The first constructor is a parameterless constructor. In this example it doesn't do anything.

The second constructor takes first and last names as parameters. It invokes the parameterless constructor and then initializes the FirstName and LastName properties. This version doesn't verify that FirstName and LastName are present and nonblank because a program could use the parameterless constructor to get around that restriction anyway.

The third constructor takes name and address parameters. It invokes the previous constructor to initialize FirstName and LastName. (That constructor in turn invokes the parameterless constructor.) It then initializes the object's remaining properties.

You can use a similar syntax to invoke a parent class constructor by simply replacing Me.New with MyBase.New.

For example, the Employee class inherits from the Person class. The following code shows three of the class's constructors:

Public Sub New()
    ' Invoke the Person constructor.
    MyBase.New()
End Sub

Public Sub New(ByVal newFirstName As String, ByVal newLastName As String)
    ' Invoke the Person constructor.
    MyBase.New(newFirstName, newLastName)
End Sub

Public Sub New(ByVal newFirstName As String, ByVal newLastName As String,
 ByVal newStreet As String, ByVal newCity As String,
 ByVal newState As String, ByVal newZip As String,
 ByVal newEmployeeId As Integer, ByVal newMailStop As String)
    ' Invoke the Person constructor.
    MyBase.New(newFirstName, newLastName, newStreet,
        newCity, newState, newZip)

    ' Initialize the remaining properties.
    EmployeeId = newEmployeeId
    MailStop = newMailStop
End Sub

The first constructor is parameterless. It invokes its parent class's parameterless constructor by using MyBase.New().

The second constructor takes first name and last name parameters and invokes the Person class's constructor, which takes two strings as parameters.

The final constructor takes eight parameters, invokes the Person class's six-parameter constructor to initialize most of the object's properties, and then initializes the last two properties (which are not inherited from the Person class) itself.

In this Try It, you enhance the Person, Employee, and Manager classes you built for the Try It in Lesson 25. In this Try It, you add constructors to make initializing objects easier.