Module 5 - Object-Oriented Programming in Visual Basic

Module 5: Object-
Oriented Programming
in Visual Basic .NET
Contents
Overview 1
Defining Classes 2
Creating and Destroying Objects 16
Demonstration: Creating Classes 23
Lab 5.1: Creating the Customer Class 24
Inheritance 31
Demonstration: Inheritance 43
Interfaces 44
Demonstration: Interfaces and
Polymorphism 50
Working with Classes 51
Lab 5.2: Inheriting the Package Class 65
Review 74
This course is based on the prerelease version (Beta 2) of Microsoft® Visual

Studio® .NET Enterprise Edition. Content in the final release of the course may be
different from the content included in this prerelease version. All labs in the course are to
be completed with the Beta 2 version of Visual Studio .NET Enterprise Edition.
Information in this document, including URL and other Internet Web site references, is subject to
change without notice. Unless otherwise noted, the example companies, organizations, products,
domain names, e-mail addresses, logos, people, places and events depicted herein are fictitious,
and no association with any real company, organization, product, domain name, e-mail address,
logo, person, place or event is intended or should be inferred. Complying with all applicable
copyright laws is the responsibility of the user. Without limiting the rights under copyright, no part
of this document may be reproduced, stored in or introduced into a retrieval system, or transmitted
in any form or by any means (electronic, mechanical, photocopying, recording, or otherwise), or
for any purpose, without the express written permission of Microsoft Corporation.
Microsoft may have patents, patent applications, trademarks, copyrights, or other intellectual
property rights covering subject matter in this document. Except as expressly provided in any
written license agreement from Microsoft, the furnishing of this document does not give you any
license to these patents, trademarks, copyrights, or other intellectual property.
© 2001 Microsoft Corporation. All rights reserved.
Microsoft, MS-DOS, Windows, Windows NT, ActiveX, BizTalk, FrontPage, IntelliSense, JScript,
Microsoft Press, Outlook, PowerPoint, Visio, Visual Basic, Visual C++, Visual C#, Visual
InterDev, Visual Studio, and Windows Media are either registered trademarks or trademarks of
Microsoft Corporation in the United States and/or other countries.
The names of actual companies and products mentioned herein may be the trademarks of their
respective owners.
Module 5: Object-Oriented Programming in Visual Basic .NET iii
Instructor Notes
Presentation: This module provides students with the knowledge required to create object-
90 Minutes oriented applications that use many of the new features of Microsoft®
Visual Basic ® .NET, such as inheritance, overloading, shared members, and
Labs: event handling.
105 Minutes
In the first lab, students will create part of the Customer class for the Cargo
system that they designed in Lab 4.1, Creating Diagrams from Use Cases. They
will define the properties, methods, and constructors, based on those shown in
Lab 4.1. Finally, they will write the code in a form to test the Customer class.
In the second lab, students will create a base class called Package and a derived
class called SpecialPackage. The classes contain some pre-written code,
including the properties. Students will add methods to both classes and create
the inheritance relationship. They will then complete a pre-written form to test
their classes.
After completing this module, students will be able to:
n Define classes.
n Instantiate and use objects in client code.
n Create classes that use inheritance.
n Define interfaces and use polymorphism.
n Create shared members.
n Create class events and handle them from a client application.
iv Module 5: Object-Oriented Programming in Visual Basic .NET
Materials and Preparation

This section provides the materials and preparation tasks that you need to teach
this module.
Required Materials
To teach this module, you need the following materials:
n Microsoft PowerPoint® file 2373A_05.ppt
n Module 5, “Object-Oriented Programming in Visual Basic .NET”
n Lab 5.1, Creating the Customer Class
n Lab 5.2, Inheriting the Package Class
Preparation Tasks
To prepare for this module, you should:
n Read all of the materials for this module.
n Read the instructor notes and the margin notes for the module.
n Practice the demonstrations.
n Complete the labs.
Module 5: Object-Oriented Programming in Visual Basic .NET v
Demonstrations
This section provides demonstration procedures that will not fit in the margin
notes or are not appropriate for the student notes.
Creating Classes
å To examine the Employee class
1. Open the Classes.sln solution in the install folder\DemoCode\
Mod05\Classes folder.
2. View the code for the Employee class and point out the private variables,
the properties, and the multiple constructors. Specifically point out the
EmployeeId read-only property.
å To test the New Employee code

1. Run the project.
2. Enter values for the First Name and the Last Name.
3. Click the New Employee button on the form. The code will enter break
mode at the preset breakpoint.
4. Step through the code, and explain each line as you go. Inc lude the Dispose
method but not the Finalize method. Point out that, in a real situation, the
Dispose method would be used for saving data and closing a database
connection.
å To test the Existing Employee code

1. Enter a positive integer value for the Id (any number will work), and then
click the Existing button.
2. Point out that this time the constructor takes the intEmpId as a parameter,
so it can load the data from a database immediately.
3. Step through the code until the object has been instantiated, and then press
F5 to allow the remaining code to run.
vi Module 5: Object-Oriented Programming in Visual Basic .NET
å To test the Improved New Employee code

1. Click the Improved New button on the form, and then step through the
code when execution halts at the preset breakpoint.
2. Point out that the constructor takes strFirstName and strLastName as
parameters so that it can create a new Employee immediately.
3. Step through the initialization code, and then press F5 to display the form
again.
4. Click the Close button to close the form and stop the application. Explain
that this will cause all remaining objects to be destroyed, and that the
Finalize methods will execute.
Remind students that the Finalize method should only be used when
resources need to be manually reclaimed (such as database connections)
because it creates more work for the garbage collector. In this case the
Finalize method calls the Dispose method again to ensure that the resources
have been reclaimed in case the class user has forgotten to call the Dispose
method explicitly. The Finalize method is not necessary if the class user has
called the Dispose method. A call to GC.SuppressFinalize within the
Dispose method would have stopped the Finalize method from executing
and would therefore have improved performance.
5. Quit the Microsoft Visual Studio ® .NET integrated development
environment (IDE).
Inheritance
å To examine the Person class
1. Open the Inheritance.sln solution in the install folder\DemoCode\
Mod05\Inheritance folder.
2. View the code for the Person class, and point out the private variables, the
properties, and the methods.
3. View the code for the Employee class, and point out that it is a simplified
version of the class used in the previous demonstration in that it has only
one constructor. Show that it inherits from the Person class and only stores
the EmployeeId value. Also, point out that the FirstName and LastName
properties are not defined in this class.
Module 5: Object-Oriented Programming in Visual Basic .NET vii
å To test the project

1. Run the project.
2. Type values in the First Name and the Last Name boxes.
3. Click the New Person button on the form. The code will enter break mode
at the first preset breakpoint.
4. Step through the code, explaining each line of code as you go. This will
include the Dispose method and the Finalize method when the GC.Collect
method is executed.
5. Point out that the Finalize method also calls the Dispose method of the
Person by means of the MyClass object.
6. Enter a positive integer value for the Id (any number will work), and click
Existing Emp.
7. Point out that this time many of the inherited properties of the Person class
are called rather than those of Employee.
8. Step through the code until the form appears again.
9. Close the form and quit the Visual Studio .NET IDE.
Interfaces and Polymorphism

å To view the application code
1. Open the Polymorphism.sln solution in the install folder\DemoCode\
Mod05\Polymorphism folder.
2. View the code for the IPerson interface. Point out the property and method
definitions and that there is no implementation code.
3. View the code for the Employee class, and point out that it now implements
Delivery Tip the IPerson interface and stores the intEmployeeId, strFName, and
Explain that students can
use either public or private strLName values. Also point out the Public EmployeeId property, the
methods within the class Private FirstName and Private LastName properties, and the new syntax
when implementing the for the Implements keyword in each method signature. Explain that
interface. because the properties are marked as private, they will only be visible from
the IPerson interface. Also explain that marking the properties as private is
optional. They could have been marked as public, making them visible from
both the IPerson interface and the Employee class.
4. View the code for the Student class, and point out that it implements the
IPerson interface and stores the strCourse, strFName, and strLName
values. Also point out that the Public Save method implements the Save
method of the IPerson interface.
viii Module 5: Object-Oriented Programming in Visual Basic .NET
å To test the application

1. Run the project.
2. Click the New Employee button on the form. The Visual Basic .NET
process will halt at the first preset breakpoint.
3. Step through the code, explaining each line as you go. Point out that both
the Employee class and the IPerson interface are used to access the various
members. The perPerson.Save method is called first to show what happens
if you use the IPerson interface. The empEmployee.SaveEmployee
method shows that you can use any name that you choose for the
implemented method.
4. Click the New Student button on the form. The code will enter break mode
at the preset breakpoint.
5. Step through the code, explaining each line as you go. Point out the
similarity in the calling code for the IPerson methods of both the Student
and Employee objects, and explain how this aids code reuse.
Handling Events
å To view the code
1. Open the Events.sln solution in the install folder\DemoCode\Mod05\Events
folder.
2. View the code for the Employee class, and point out the DataChanged
event in the declarations section and its purpose. In the FirstName property,
point out the raising of the event and the purpose of the code that checks the
blnCancelled value.
3. View the code for the frmEvents form, and point out the module-level
variable that uses WithEvents.
4. Click the Class Name combo box, and then click empEmployee. In the
Method Name combo box, click DataChanged. Examine the default event
handler code, and point out the Handles keyword in the function declaration.
å To test the events

1. Run the project.
2. Click the WithEvents button on the form. The code will enter break mode
3. Step through the code, explaining each line of code as you go. This will
include the RaiseEvent code in the Employee class.
4. Click the AddHandler button on the form. The code will enter break mode
5. Explain the AddHandler statement, and examine the
EmployeeDataChange method at the end of the code for the form.
6. Continue debugging as the events are raised to the EmployeeDataChange
method.
Module 5: Object-Oriented Programming in Visual Basic .NET ix
Module Strategy
Use the following strategy to present this module:
n Defining Classes
This lesson describes how to create classes in Visual Basic .NET. Students
will learn how to declare methods and properties, and how to overload class
members. When you introduce students to class constructors and destructors,
including multiple constructors, point out that the Finalize method should
only be used when resources need to be manually reclaimed (such as
database connections) because this method adds overhead to the disposing
of objects.
Some of this lesson contains simple tasks such as how to create classes and
methods. Cover these areas quickly so that more time can be spent on new
features, such as the syntax for defining properties and constructors.
n Creating and Destroying Objects
This lesson describes how to declare, instantiate, and initialize objects.
Contrast this approach to the approach used in previous versions of
Visual Basic to show the usefulness of constructors.
Introduce garbage collection as an important change in the way objects are
destroyed. Ensure that students understand this process, because many
developers will be unaware of the potential dangers. Present the Dispose
method as a suggested way to handle issues raised by garbage collection.
Point out that the notes present two common techniques for creating the
Dispose method, and that the IDisposable interface provides a more
consistent approach. If time permits, you may want to show students the
“GC Class”topic in the Visual Studio .NET documentation.
Use the instructor-led demonstration to demonstrate how to create classes
that contain multiple constructors. In this demonstration, you will also show
how to instantiate and use classes from calling code.
Have students complete the first lab after the demonstration.
n Inheritance
This lesson explains how to use the new Visual Basic .NET class
inheritance features. Introduce students to member overriding, the MyBase
keyword, and the MyClass keyword. These important features will be new
to many students, so be prepared to demonstrate different scenarios to
reiterate the concepts.
Use the instructor-led inheritance demonstration to show how to use the
various keywords to create a simple Person class that is used as a base class
for an Employee class.
x Module 5: Object-Oriented Programming in Visual Basic .NET
n Interfaces
This lesson explains how to define interfaces in Visual Basic .NET and
examines the various ways to achieve polymorphism.
Use the instructor-led polymorphism demonstration to show how to use
interfaces to define an IPerson interface that is then implemented by
Student and Employee classes.
This lesson will be a challenge for many students. You will need to gauge
the level of understanding and decide how much time to spend on the
material and the demonstration. Tell students where they can find additional
information about this topic, possibly including books or white papers.
For more information about interfaces and polymorphism, search for
“interfaces and polymorphism” in the Visual Studio .NET documentation
and at http://msdn.microsoft.com
n Working with Classes
This lesson shows how to create shared members, events, and delegates.
The Event Handing topic mentions the AddressOf operator but does not
explain it in depth because it is not new to Visual Basic .NET. Some
students, however, may require a more detailed explanation.
Students may also find the concept of delegates to be difficult. A detailed
example is provided in the student notes, and you may need to go through
this example with the students. This example is also provided in the
DemoCode folder, although no instructions accompany this code.
Use the instructor-led demonstration to show how to define and handle
events in a simple class.
Module 5: Object-Oriented Programming in Visual Basic .NET 1
Overview
Topic Objective
To provide an overview of
the module topics and
objectives. n Defining Classes
Lead-in
In this module, you will learn
n Creating and Destroying Objects
how to implement object- n Inheritance
oriented programming in
Visual Basic .NET. n Interfaces
In this module, you will learn how to implement object-oriented programming

Delivery Tip in Microsoft® Visual Basic ® .NET version 7.0. You will learn how to define
This module introduces
many important new classes, their properties, and their methods. You will learn about the life cycle
features of of an object, from creation to destruction. You will also learn how to work with
Visual Basic .NET. Ensure classes by using inheritance, interfaces, polymorphism, shared members, events,
that students fully and delegates.
understand these concepts
before moving on to the next After completing this module, you will be able to:
module. n Define classes.
n Instantiate and use objects in client code.
n Create classes that use inheritance.
n Define interfaces and use polymorphism.
n Create shared members.
n Create class events and handle them from a client application.
2 Module 5: Object-Oriented Programming in Visual Basic .NET
u Defining Classes
Topic Objective
the topics covered in this
lesson. n Procedure for Defining a Class
Lead-in
This lesson explains how to n Using Access Modifiers
define classes. n Declaring Methods
n Declaring Properties
n Using Attributes
n Overloading Methods
n Using Constructors
n Using Destructors
In this lesson, you will learn how to define classes in Visual Basic .NET. After
completing this lesson, you will be able to:
n Specify access modifiers (scope) for classes and their procedures.
n Declare methods and properties within a class.
n Use attributes to provide metadata about your code.
n Pass different parameters to one method by using overloading.
n Create and destroy objects.
Procedure for Defining a Class

Topic Objective
To outline the procedure for
defining a class. Add a Class to the Project
Lead-in
Defining a class is a simple Provide an Appropriate Name for the Class
procedure.
Create Constructors As Needed
Create a Destructor, If Appropriate
Declare Properties
Declare Methods and Events
To define a class in Visual Basic .NET, you can follow this general procedure:
1. Add a class to the project.
Delivery Tip
Point out that you can define 2. Provide an appropriate file name for the class when you add it. This will
as many classes as you name both the file and the class itself. If you do not change the file name
need in a module. You are when you add it, you can change the class name at any time by changing the
not limited to one class per class definition in the code window.
file, as you are in previous
versions of Visual Basic. 3. Create constructors as needed.
4. Create a destructor if appropriate.
5. Declare properties.
6. Declare methods and events.
Note In Visual Basic .NET, you can define more than one class in a single file.
You are not limited to one class per file, as you are in previous versions of
Visual Basic, because classes are a block level construct.
Using Access Modifiers

Topic Objective
To describe the access
modifiers that are available
in Visual Basic .NET. n Specify Accessibility of Variables and Procedures
Lead-in
Before looking at the details Keyword Definition
for defining classes, you Public Accessible everywhere.
need to understand how Private Accessible only within the type itself.
access modifiers affect
classes. Friend Accessible within the type itself and all
namespaces and code within the same assembly.
Protected Only for use on class members. Accessible within
the class itself and any derived classes.
Protected The union of Protected and Friend.
Friend
You can use access modifiers to specify the scope of the variables and
procedures in the class that you define. Visual Basic .NET retains three access
modifiers that are used in previous versions of Visual Basic and adds two more:
Protected and Protected Friend. The following table defines the five access
modifiers available in Visual Basic .NET.
Access modifier Definition
Public Accessible everywhere.

Private Accessible only within the type itself.
Friend Accessible within the type itself and all namespaces and code
within the same assembly.
Protected Accessible within the class itself and, if other classes are inheriting
from the class, within any derived classes. Protected members are
available outside of an assembly when inherited by derived
classes.
Protected Friend The union of Protected and Friend. Accessible to code within the
same assembly and to any derived classes regardless of the
assembly to which they belong.
Note Inheritance in Visual Basic .NET is described in detail in the Inheritance

lesson of this module.
Declaring Methods
Topic Objective
To explain how to declare
methods in a class.
Lead-in n Same Syntax As in Visual Basic 6.0
The syntax for declaring
methods in a class has Public
Public Sub
Sub TestIt(ByVal
TestIt(ByVal xx As
As Integer)
Integer)
not changed in ...
...
End
End Sub
Visual Basic .NET. Sub
Public
Public Function
Function GetIt(
GetIt( )) As
As Integer
Integer
...
...
End
End Function
Function
You use the same syntax to declare a method in Visual Basic .NET that you
used in Visual Basic 6.0, as shown in the following example:
Public Class TestClass
Public Sub TestIt(ByVal x As Integer)

...
End Sub
Public Function GetIt( ) As Integer

...
End Function
End Class
Declaring Properties
Topic Objective
To explain how to declare
properties in a class.
n Syntax Differs from That of Visual Basic 6.0
Lead-in
The syntax for declaring Public
Public Property
Property MyData(
MyData( )) As
As Integer
Integer
class properties has Get
Get
changed significantly in Return
Return intMyData
intMyData 'Return
'Return local
local variable
variable value
value
End
End Get
Visual Basic .NET. Set
Get
Set (ByVal
(ByVal Value
Value As
As Integer)
Integer)
intMyData
intMyData == Value
Value 'Store
'Store Value
Value in
in local
local variable
variable
End
End Set
Set
End
End Property
Property
n ReadOnly, WriteOnly, and Default Keywords

Public
Public ReadOnly
ReadOnly Property
Property MyData(
MyData( )) As
As Integer
Integer
Get
Get
Return
Return intMyData
intMyData
End
End Get
Get
End Property
End Property
The syntax for declaring class properties has changed significantly in

Delivery Tip Visual Basic .NET.
This is an animated slide. It
begins by showing the
property syntax. Click the Syntax for Declaring Properties
slide to reveal a ReadOnly In Visual Basic 6.0, you create properties by declaring two separate procedures:
example. one for the Get and one for the Let orSet. In Visual Basic .NET, you declare
your properties by using two code blocks in a single procedure, as follows:
[Default|ReadOnly|WriteOnly] Property varname ([parameter
list]) [As typename]
Get
[block]
End Get
Set (ByVal Value As typename )
[block]
End Set
End Property
When you create a property declaration, the Visual Basic .NET Code Editor
inserts a template for the remainder of the property body.
Example
The following example shows how to declare a property called MyData of type
Integer. The Get block returns an unseen local variable called intMyData by
using a Return statement. The Set block uses the Value parameter to store the
passed-in property value to the intMyData local variable.
Private intMyData As Integer
Public Property MyData( ) As Integer

Get
Return intMyData
End Get
Set (ByVal Value As Integer)
intMyData = Value
End Set
End Property
Using Read-Only Properties

You can create read-only properties by using the ReadOnly keyword when you
declare the property. Read-only properties cannot be used in an assignment
statement. The following example shows how to specify a read-only property:
Public ReadOnly Property MyData( ) As Integer
Get
Return intMyData
End Get
End Property
You cannot use the Set block when defining read-only properties because the
property cannot be updated. The compiler will generate an error if you attempt
to do this.
Using Write-Only Properties

You can create write-only properties by using the WriteOnly keyword when
you declare the property. Write-only properties cannot be used to retrieve the
value of the property. The following example shows how to create a write-only
property:
Public WriteOnly Property MyData( ) As Integer
Set (ByVal Value As Integer)
intMyData = Value
End Set
End Property
You cannot use the Get block when defining write-only properties because the
property is not readable. The compiler will generate an error if you attempt to
do this.
Using Default Properties

You can create a default property for a class by using the Default keyword
when you declare the property. You must code the property to take at least one
argument, and you must specify Public, Protected, or Friend access.
The following example shows how to declare a default property that takes an
index as an argument and returns a Boolean value:
Default Public Property Item(ByVal index As Integer) _
As Boolean
Get
Return myArray(index) 'Uses a private module -level array
End Get
Set(ByVal Value As Boolean)
myArray(index) = Value
End Set
End Property
Using Attributes
Topic Objective
To explain how to use
attributes.
Lead-in n Extra Metadata Supplied by Using “< >” Brackets
Attributes provide extra
information about your code.
n Supported for:
l Assemblies, classes, methods, properties, and more
n Common Uses:
l Assembly versioning, Web Services, components,
security, and custom
<Obsol
<Obsol e e ttee((""PPl leeaassee uussee mmeetthhoodd M M22 "" )) >> Publ
P u b il icc S
Sub
u b M1(
M1 ( ) )
' ' RReessuul lt tss i inn wwaarrnni inngg i inn IIDDEE wwhheenn uusseedd bbyy cclliieenntt ccooddee
End
End SubSub
You can use attributes to provide extra information or metadata to the

developers who read your code. In Visual Basic .NET, you use angular brackets
(< and >) to specify an attribute.
You can apply attributes to many items within your application, including
Delivery Tip
assemblies, modules, classes, methods, properties, parameters, and fields in
Discuss some of the
modules, classes, and structures.
common uses for attributes,
but point out that we will Here are some examples of how to use attributes:
cover individual attributes
throughout the course. n In assemblies, you can specify metadata including the title, description, and
version information of the assembly.
n When creating a Web Service, you can define which methods are accessible
as part of the service, in addition to adding descriptions to the methods.
n When designing Windows Forms controls, you can specify information to
display in the property browser, or you can set the Toolbox icon.
n For components that use enterprise services, you can set transaction and
security settings.
Functionality is provided by the Microsoft .NET Framework to allow you to

create your own custom attributes and use them as you want in your
applications.
Note For more information about creating custom attributes, see “Writing
Custom Attributes” in the Microsoft Visual Studio ® .NET documentation.
Example
The following example shows how to use the Obsolete attribute to warn
developers that a method can no longer be used. An optional message is
displayed in the Task List window if a developer attempts to use this method.
Using the Obsolete method will not create an error when the application is
compiled, but will generate a warning as follows:
<Obsolete("Please use method M2")> Public Sub M1( )
'Results in warning in IDE when used by client code
End Sub
Note All attributes are simply classes that inherit from the Attribute class and
provide constructors. The Obsolete class provides a single constructor that
takes a string as the parameter.
Overloading Methods
Topic Objective
To introduce the concept
and syntax of overloading in
Visual Basic .NET. n Methods with the Same Name Can Accept Different
Parameters
Lead-in
Overloading is a powerful Public
Public Function
Function Display(s
Display(s As As String)
String) As
As String
String
MsgBox("String:
MsgBox("String: "" && s)
object-oriented feature that Return "String"
s)
Return "String"
allows multiple methods to End
End Sub
Sub
have the same name but Public
Public Function
Function Display(i
Display(i As
As Integer)
Integer) As
As Integer
Integer
accept different parameters. MsgBox("Integer:
MsgBox("Integer: "" && i)
i)
Return
Return 11
End
End Function
Function
n Specified Parameters Determine Which Method to Call

n The Overloads Keyword is Optional Unless Overloading
Inherited Methods
Overloading is a powerful object-oriented feature that allows multiple methods

to have the same name but accept different parameters. Overloading allows
Delivery Tip
Students who are familiar calling code to execute one method name but achieve different actions,
with Microsoft Visual C++ depending on the parameters you pass in.
will understand operator
overloading. You might want For overloading to occur, the method signature must be unique. You can
to ask for examples from achieve this by changing the number of parameters in the signature or by
these students. changing the data types of the parameters. Changing the way a parameter is
passed (that is, by value or by reference) does not make a signature unique, nor
does changing a function return data type.
You can optionally specify a method as overloaded with the Overloads
keyword. If you do not use the keyword, the compiler assumes it by default
when you declare multiple methods that have the same name. However, when
overloading a method from an inherited class, you must use the Overloads
keyword.
Note Overloading a method from an inherited class will be discussed in the

Inheritance lesson of this module.
The following example shows how to overload a method. This code allows
different types of information (string, integers, and so on) to be displayed by
calling the Display method of a class and passing in different parameters.
Public Function Display(s As String) As String

MsgBox("String: " & s)
Return "String"
End Sub
Public Function Display(i As Integer) As Integer

MsgBox("Integer: " & i)
Return 1
End Function
When you call the Display method, the parameters you specify determine
which overloaded method will be called.
Without using overloading, you need two different methods , such as
DisplayString and DisplayInteger, to accept the different types of parameters
in the preceding example.
Note If the Option Strict compiler option is on, you must explicitly declare
values as specific types when passing them to the overloaded methods as
parameters, and the compiler can identify which instance of the method to call.
If Option Strict is off and a generic variable (such as Object ) is passed as a
parameter, the decision of which instance of the method to call is left until run
time. For more information about overload resolution, see “Procedure
Overloading” in the Visual Studio .NET documentation.
Using Constructors
Topic Objective
To explain the concept and
syntax of class constructors.
Lead-in n Sub New Replaces Class_Initialize
Visual Basic .NET allows
you to create class n Executes Code When Object Is Instantiated
constructors. Public
Public Sub
Sub New(
New ( ))
'Perform
'Perform simple
simple initialization
initialization
intValue
intValue == 11
End
End Sub
Sub
n Can Overload, But Does Not Use Overloads Keyword

Public
Public Sub
Sub New(ByVal
New(ByVal ii As
As Integer)
Integer) 'Overloaded
'Overloaded without
without Overloads
Overloads
'Perform
'Perform more
more complex
complex initialization
initialization
intValue
intValue == ii
End
End Sub
Sub
In Visual Basic 6.0, you place initialization code in the Class_Initialize event
Delivery Tip of your class. This code is executed when the object is instantiated, and you can
begins by showing the first use it to set initial values of local variables, to open resources, or to instantiate
example. Click the slide to other objects.
reveal an example of
In Visual Basic .NET, you control the initialization of new objects by using
overloading.
procedures called constructors. The Sub New constructor replaces the
Class_Initialize event and has the following features:
n The code in the Sub New block will always run before any other code in a
class.
n Unlike Class_Initialize , the Sub New constructor will only run once: when
an object is created.
n Sub New can only be called explicitly in the first line of code of another
constructor, from either the same class or a derived class using the MyBase
keyword.
Using Sub New

The following example shows how to use the Sub New constructor:
Public Sub New( )
'Perform simple initialization
intValue = 1
End Sub
The change in Visual Basic .NET from the Class_Initialize event to the Sub
New constructor means you can overload the New subroutine and create as
many class constructors as you require. This is useful if you want to initialize
your object when you instantiate it. To do this in Visual Basic 6.0, you must
call methods or properties after the object is created.
Overloading Constructors
You can overload constructors just as you can overload any other method in a
class. However, you cannot us e the Overloads keyword when overloading
constructors. The following example shows how to overload the New
subroutine and create multiple class constructors:
Public Sub New( ) 'Perform simple initialization
intValue = 1
End Sub
Public Sub New(ByVal i As Integer)

'Perform more complex initialization
intValue = i
End Sub
Public Sub New(ByVal i As Integer, _

ByVal s As String)
intValue = i
strValue = s
End Sub
Using Destructors
Topic Objective
To explain destructors
and their syntax in
Visual Basic .NET. n Sub Finalize Replaces Class_Terminate Event
Lead-in
Destructors are used to n Use to Clean Up Resources
destroy objects in n Code Executed When Destroyed by Garbage Collection
Visual Basic .NET.
l Important: destruction may not happen immediately
Protected
Protected Overrides
Overrides Sub
Sub Finalize(
Finalize( ))
'Can
'Can close
close connections
connections or
or other
other resources
resources
conn.Close
conn.Close
End
End Sub
Sub
In Visual Basic .NET, you can control what happens during the destruction of
objects by using procedures called destructors.
The new Finalize destructor replaces the Class_Terminate event found in
Delivery Tip previous versions of Visual Basic. This subroutine is executed when your object
Point out that the Finalize is destroyed, and you can use it to clean up open resources, such as database
method should only be used connections, or to release other objects in an object model hierarchy.
where necessary so it
doesn’t cause unnecessary The following example shows how to use the Finalize destructor:
processing during object
Protected Overrides Sub Finalize( )
clean-up.
'Can close connections of other resources
conn.Close
End Sub
Note You will learn about the Overrides keyword in the Inheritance lesson of
this module.
In Visual Basic 6.0, the Class_Terminate event runs when an object is no

Delivery Tip
longer being referenced by any variables. You use the Set x = Nothing
Point out that garbage
collection is covered in more statement to release a particular reference. When all the references are gone, the
event executes and resources can be cleaned up.
depth in the next lesson.
In Visual Basic .NET, when you set an object reference to Nothing, you still
release variables. However, the object may not be destroyed until a later stage
due to the introduction of garbage collection.
u Creating and Destroying Objects

Topic Objective
lesson. n Instantiating and Initializing Objects
Lead-in
In this lesson, you will learn n Garbage Collection
about creating and n Using the Dispose Method
destroying objects.
In this lesson, you will learn about creating and destroying objects. After
completing this lesson, you will be able to:
n Instantiate and initialize objects.
n Explain the role that garbage collection plays in the object life cycle.
n Use the Dispose method to destroy an object and safely clean up its
resources.
Instantiating and Initializing Objects

Topic Objective
To explain how to instantiate
and initialize objects.
n Instantiate and Initialize Objects in One Line of Code
Lead-in
The method for instantiating 'Declare
‘declare
‘declare but
'Declare but don
do
do not
’t
notinstantiate
don’t instantiate
instantiateyet
instantiate yet
yet
yet
and initializing objects Dim c1 As TestClass
Dim c1 As TestClass
has changed in ‘other
'Other
‘other code
'Other code
code
c1
c1 == New
New TestClass(
TestClass()
TestClass())) ‘instantiate
'Instantiate
‘instantiate now
Visual Basic .NET. TestClass( 'Instantiate now
'Declare,
‘declare,
‘declare, instantiate
'Declare, instantiate && initialize
initialize using
using default
default constructor
constructor
Dim
Dim c2
c2 As
As TestClass
TestClass == New
New TestClass(
TestClass()
TestClass()))
TestClass(
'Declare,
‘declare,
‘declare, instantiate
'Declare, instantiate && initialize
initialize using
using default
default constructor
constructor
Dim
Dim c3
c3 As
As New
New TestClass(
TestClass
TestClass ))
TestClass(
'Declare,
'Declare, instantiate
instantiate && initialize
initialize using
using alternative
alternative constructor
constructor
Dim
Dim c4
c4 As
As New
New TestClass(10)
TestClass(10)
Dim
Dim c5
c5 As
As TestClass
TestClass == New
New TestClass(10)
TestClass(10)
You can now instantiate and initialize objects in one line of code. This means
you can write simpler and clearer code that can call different class constructors
for multiple variables.
Delivery Tip Example 1

The following example shows how to declare a variable in one line and
begins by showing the first
part of the example. Click instantiate it in a following line. Remember that the Set keyword is no longer
the slide to reveal the needed.
following sections:
'Declare but do not instantiate yet
1. c2 example
Dim c1 As TestClass
2. c3 example
3. c4 and c5 example 'Other code
c1 = New TestClass( ) 'Instantiate now
Example 2
The following example shows how to declare, instantiate, and initialize an
object in one statement. The default constructor for the class will be executed.
'Declare, instantiate & initialize using default constructor
Delivery Tip Dim c2 As TestClass = New TestClass( )
Ensure that students are
aware of the differences
between the behavior of the
following statement in
Visual Basic .NET as
opposed to previous
versions of Visual Basic:
Dim x As New TestClass
Example 3
The following example performs the same functionality as Example 2. It looks
similar to code from previous versions of Visual Basic, but behaves quite
differently.
'Declare, instantiate & initialize using default constructor
Dim c3 As New TestClass
Visual Basic 6.0

In Visual Basic 6.0, the preceding code creates the object when the object is
first used. If you destroy the variable by assigning the Nothing keyword, it will
automatically be recreated w hen it is next referenced.
Visual Basic .NET

In Visual Basic .NET, the preceding code declares and instantiates the object
variables immediately. If you destroy the variable by assigning the Nothing
keyword, it will not automatically be recreated when it is next referenced.
Example 4
The following examples show how to declare, instantiate, and initialize objects
in single statements. Both statements call alternative constructors for the class.
'Declare, instantiate & initialize using alternate constructor
Dim c4 As New TestClass(10)
Dim c5 As TestClass = New TestClass(10)
Garbage Collection
Topic Objective
To explain garbage
collection and how it affects
object lifetime. n Background Process That Cleans Up Unused Variables
Lead-in n Use x = Nothing to Enable Garbage Collection
Garbage collection
significantly alters how n Detects Objects or Other Memory That Cannot Be
objects are destroyed. Reached by Any Code (Even Circular References!)
n Calls Destructor of Object
l No guarantee of when this will happen
l Potential for resources to be tied up for long periods of
time (database connections, files, and so on)
l You can force collection by using the GC system class
In previous versions of Visual Basic, object destruction is based on a reference

count. References are removed when you set the object to Nothing or when the
variable goes out of scope. When all references to an object have been removed,
the object is destroyed. This is effective in most situations, but some objects,
such as those left orphaned in a circular reference relationship, may not be
destroyed.
In Visual Studio .NET, setting an object reference to Nothing or allowing it to
go out of scope removes the link from the variable to the object and allows
garbage collection to take place. This background process traces object
references and destroys those that cannot be reached by executing code,
including objects that are not referenced. The garbage collector executes the
object destructor (the Finalize method discussed earlier in this module.)
Garbage collection provides several performance advantages:
n It cleans up circular references and improves code performance because
objects do not need to keep a reference count.
n Because reference counting is no longer required, the time taken to
instantiate an object is reduced.
n The time taken to release an object variable reference is reduced.
n No storage is required for the reference count, which means that the amount
of memory that an object uses is also reduced.
It is important to note that garbage collection introduces a time delay between

when the last reference to an object is removed and when the collector destroys
the object and reclaims the memory. This time delay can be quite significant if
the object is holding open resources that may affect the scalability or
performance of the application, such as database connections.
It is possible to attempt to force the collection of unused objects by using the

GC (Garbage Collector) system class’Collect method as follows:
GC.Collect( )
However, using the Collect method is not recommended because forcing

garbage collection may result in poor performance because of the unnecessary
collection of other unused objects. You should instead use a standard method
such as Dispose , which is discussed in the next topic.
Using the Dispose Method

Topic Objective
To explain how to use the
Dispose method to aid
resource management. n Create a Dispose Method to Manually Release Resources
Lead-in 'Class
'Class code
code
One way to overcome the Public
Public Sub
Sub Dispose(
Dispose( ))
time delay issue of garbage 'Check
'Check that
that the
the connection
connection is
is still
still open
open
collection is to use a conn.Close 'Close
'Close a database connection
a database
standard method such as conn .Close connection
End
End Sub
the Dispose method. Sub
n Call the Dispose Method from Client Code

'Client
'Client code
code
Dim
Dim xx as
as TestClass
TestClass == New
New TestClass(
TestClass( ))
...
...
x.Dispose(
x.Dispose( )) 'Call
'Call the
the object's
object's dispose
dispose method
method
Because of the potential time delay created by garbage collection, you may
Delivery Tip
want to create a standard method called Dispose for your class. Many
Visual Studio .NET objects use this method to clean up resources.
Dispose example. Click the When client code has no further need for an object’s resources, it can directly
slide to reveal the client
call code placed in the Dispose method of the object. If the client code does not
code example.
call the Dispose method explicitly before garbage collection occurs, the
Point out that you must be Finalize method of the class can also call the Dispose method. However, note
cautious when executing that you may cause an exception if you attempt to run the Dispose code twice.
code in the Finalize method An exception can occur if you have already closed or released an object and do
if resources have been not test to determine whether it still exists in the second execution of the
cleaned up in a Dispose Dispose code.
method.
Example
The following simple example shows how to create a Dispose method to
manually release resources:
'Class code
Public Sub Dispose( )
'Check that the connection is still open
...
conn.Close 'Close a database connection
End Sub

Dispose( ) 'Optional call to Dispose
End Sub
'Client code
Dim x as TestClass = New TestClass( )
...
x.Dispose( ) 'Call the object's dispose method
The IDisposable Interface

Visual Basic .NET provides an interface called IDisposable to improve
accuracy and consistency among objects. This interface provides one method,
Dispose, which does not take any arguments. By implementing this interface in
all of your classes, you will consistently provide a Dispose method that can be
easily called by client code.
Note You will learn how to implement interfaces in the Interfaces lesson of
this module.
If you completely clean up your object in a Dispose method (whether you use
IDisposable or not), garbage collection does not need to execute your Finalize
method. You can disable the execution of the Finalize method by calling the
SuppressFinalize method on the GC object, as shown in the following
example. This method accepts a single argument that is a reference to the object
that should not have its Finalize method called. In Visual Basic .NET, this is
done with the Me keyword.
In the following example, if the client code called the Dispose method directly,
the connection would be closed and the Finalize method would not be called by
garbage collection. If the client did not call the Dispose method, the Finalize
method will still execute when garbage collection destroys the object.
'Class code
Public Sub Dispose( )
'Check that the connection is still open
...
conn.Close 'Close a database connection
GC.SuppressFinalize(Me)
End Sub

Dispose( ) 'Optional call to Dispose
End Sub
Demonstration: Creating Classes

Topic Objective
To demonstrate how to
create and use simple
classes.
Lead-in
This demonstration will
show you how to define
classes and instantiate and
destroy objects.
In this demonstration, you will learn how to define a simple class that uses
Delivery Tip
multiple constructors. You will also learn how to instantiate and use the class
The step-by-step
from within client code.
instructions for this
demonstration are in the
instructor notes for this
module.
Lab 5.1: Creating the Customer Class

Topic Objective
To introduce the lab.
Lead-in
In this lab, you will define
the Customer class for the
Cargo system.
Explain the lab objectives.

Objectives
After completing this lab, you will be able to:
n Create classes.
n Instantiate, initialize, and use classes from calling code.
Prerequisites
Before working on this lab, you should be familiar with creating classes in
Visual Basic .NET.
Scenario
In this lab, you will begin creating the Cargo system. You will create the
Customer class and a test application to instantiate, initialize, and test the class.
Starter and Solution Files

There are starter and solution files associated with this lab. The starter files are
in the install folder\Labs\Lab051\Starter folder, and the solution files are in the
install folder\Labs\Lab051\Solution folder.
Estimated time to complete this lab: 45 minutes

Exercise 1
Defining the Customer Class
In this exercise, you will define the Customer class. The starter project
contains several forms that you will use to test your Customer class.
å To open the starter project

1. Open Visual Studio .NET.
2. On the File menu, point to Open, and then click Project. Set the folder
location to install folder\Labs \Lab051\Starter, click Lab051.sln, and then
click Open.
å To create the Customer class

1. On the Project menu, click Add Class.
2. In the Add New Item dialog box, change the name of the class file to
Customer.vb, and click Open.
å To define the class properties

1. Add the following private variables to the class definition.
Variable name Data type
intCustomerID Integer
strFName String
strLName String
strEmail String
strPassword String
strAddress String
strCompany String
2. Add the following public properties, and use these to access the private
variables created in the previous step.
Property name Read/Write access Data type
CustomerID Read-only Integer
FirstName Read-write String
LastName Read-write String
Email Read-write String
Password Read-write String
Address Read-write String
Company Read-write String
3. Save the project.

å To define the class methods

1. Add the following methods to the class definition.
Method name Type Parameters
LogOn Public Sub ByVal strEmail As String
ByVal strPassword As String
AddCustomer Public Function ByVal strEmail As String

ByVal strPassword As String
ByVal strFName As String
ByVal strLName As String
ByVal strCompany As String
ByVal strAddress As String
<RETURN VALUE> As Integer
New Public Sub <None>
New Public Sub ByVal intID As Integer
2. On the File menu, point to Open, and click File. In the Files of type list,
click Text Files. Click Code.txt, and then click Open.
3. Locate the LogOn code in Code.txt. Copy the procedure code to the LogOn
method of the Customer class.
4. Locate the AddCustomer code in Code.txt. Copy the procedure code to the
AddCustomer method of the Customer class.
å To complete the class constructors

1. In the Customer class, locate the default constructor definition (the Sub
New without parameters), and initialize the intCustomerID variable to -1.
2. Locate the alternative constructor code in Code.txt. Copy the procedure
code to the parameterized constructor of the Customer class.
Exercise 2
Testing the LogOn Procedure
In this exercise, you will test the LogOn procedure from a simple form.
å To create the Logon button code

1. Open frmLogOn in the Code Editor and locate the btnLogOn_Click event
procedure.
2. Declare and instantiate a Customer variable called cusCustomer.
3. Call the LogOn method of the cusCustomer object, passing in the text
properties of txtEmail and txtPassword as parameters.
4. Display the properties of the cusCustomer object in the appropriate text
boxes. Use the information in the following table:
Text box Property of cusCustomer
txtID CStr(CustomerID)
txtFName FirstName
txtLName LastName
txtAddress Address
txtCompany Company
5. Set cusCustomer to Nothing.

å To test the LogOn code

1. Set a breakpoint on the first line of the btnLogOn_Click procedure.
2. On the Debug menu, click Start. On the menu form, click Test ‘Logon’to
display the test form, and then type the following values in the appropriate
text boxes.
Text box Value
E-mail karen@wingtiptoys.msn.com
Password password
3. Click the Logon button, and step through the procedure.

4. Confirm that your code retrieves the customer information and displays it
correctly in the text boxes. Close the form.
5. Reopen the LogOn form and enter the following incorrect values in the
appropriate text boxes.
Textbox Value
E-mail john@tailspintoys.msn.com
Password john
6. Click the Logon button, and step through the procedure.

7. Confirm that your code causes an exception to be generated and handled by
the form.
8. Click the Close button to quit the application. Remove the breakpoint on
btnLogOn_Click.
Exercise 3
Testing Customer Retrieval
In this exercise, you will test the parameterized constructor that retrieves the
customer details from a simple form. A sales agent who needs full access to the
customer’s information could use this type of form.
å To create the Retrieve button code

1. Open frmRetrieve in the Code Editor, and locate the btnRetrieve_Click
event procedure.
2. Declare and instantiate a Customer variable called cusCustomer. Use the
parameterized constructor to pass in the existing customer ID from the txtID
text box. (Use the CInt function to convert it to an integer value.)
3. Display the properties of the cusCustomer object in the appropriate text
boxes. Use the information in the following table:
Textbox Property of cusCustomer
txtEmail Email
txtPassword Password
txtFName FirstName
txtLName LastName
txtAddress Address
txtCompany Company
å To test the Retrieve code

1. Set a breakpoint on the first line of the btnRetrieve_Click procedure.
2. On the Debug menu, click Start. On the menu form, click Test ‘Get
Details’to display the test form, and then type the value 1119 in the
CustomerID text box.
3. Click the Retrieve button, and step through the procedure.
4. Confirm that your code retrieves the customer information and displays it
correctly in the text boxes.
5. Click the Clear Data button to reset the information, and type the value
1100 in the CustomerID text box.
6. Click the Retrieve button, and step through the procedure.
7. Confirm that your code causes an exception to be generated and handled by
the form.
btnRetrieve_Click.
Exercise 4
Testing the AddCustomer Procedure
In this exercise, you will test the AddCustomer procedure from a simple form.
å To create the Add Customer button code

1. Open frmNew in the Code Editor, and locate the btnNew_Click event
procedure.
2. Declare and instantiate a Customer variable called cusCustomer.
3. Call the AddCustomer function of the cusCustomer object, passing in the
appropriate values and displaying the return value in a message box. Use the
CStr function to convert the integer value to a string. Use the information in
the following table:
Parameter name Value
strEmail txtEmail.Text
strPassword txtPassword.Text
strFName txtFName.Text
strLName txtLName.Text
strCompany txtCompany.Text
strAddress txtAddress.Text
å To test the Add Customer code

1. Set a breakpoint on the first line of the btnNew_Click procedure.
2. On the Debug menu, click Start. On the menu form, click Test ‘New
Customer’to display the test form.
3. Enter values in all text boxes.
4. Click the New Customer button, and step through the procedure.
5. Confirm that your code passes the information to the procedure correctly,
and that a new ID is returned.
6. Click the Close button and quit the application. Remove the breakpoint on
btnNew_Click.
u Inheritance
Topic Objective
To provide an ov erview of
lesson. n What Is Inheritance?
Lead-in
In this lesson, you will learn n Overriding and Overloading
about inheritance. n Inheritance Example
n Shadowing
n Using the MyBase Keyword
n Using the MyClass Keyword
In this lesson, you will learn how to implement class inheritance. After
Delivery Tip completing this lesson, you will be able to:
Inform students that
although inheritance is an n Inherit from an existing class.
important new feature of
Visual Basic .NET, you can n Override and overload some base class methods in a derived class.
continue to create classes n Use the MyBase keyword to access the base class from a derived class.
without inheritance, as in
previous versions of n Use the MyClass keyword to ensure that you call the correct class.
Visual Basic.
What Is Inheritance?
Topic Objective
To explain the keywords
and syntax for class n Derived Class Inherits from a Base Class
inheritance.
n Properties, Methods, Data Members, Events, and Event
Lead-in Handlers Can Be Inherited (Dependent on Scope)
Inheriting a class allows you
to use the features of a base n Keywords
class without rewriting the
code. l Inherits – inherits from a base class
l NotInheritable – cannot be inherited from
l MustInherit – instances of the class cannot be created;
must be inherited from as a base class
l Protected – member scope that allows use only by
deriving classes
In Visual Basic .NET , you can use inheritance to derive a class from an existing
base class. The derived class can inherit all the base class properties, methods,
Delivery Tip data members, events, and event handlers, making it easy to reuse the base class
Point out that inheritance code throughout an application.
can be used to create highly
reusable code. However, The Inherits Keyword
many applications do not
need inheritance and can The following example shows how to use the Inherits keyword to define a
perform perfectly well derived class that will inherit from an existing base class:
without it. Make clear that if
Public Class DerivedClass
inheritance is used, students
should not create complex Inherits BaseClass
hierarchies that will become ...
unmanageable. End Class
The NotInheritable Keyword

The following example shows how to use the NotInheritable keyword to
define a class that cannot be used as a base class for inheritance. A compiler
error is generated if another class attempts to inherit from this class.
Public NotInheritable Class TestClass
...
End Class
Inherits TestClass 'Generates a compiler error
...
End Class
The MustInherit Keyword

You use the MustInherit keyword to define classes that are not intended to be
used directly as instantiated objects. The resulting class must be inherited as a
base class for use in an instantiated derived class object. If the client code
attempts to instantiate an object based on this type of class, a compiler error is
generated, as shown in the following example:
Public MustInherit Class BaseClass
...
End Class
...
'Client code
Dim x As New BaseClass( ) 'Generates a compiler error
The Protected Keyword

You use Protected access to limit the scope of a property, method, data
member, event, or event handler to the defining class and any derived class
based on that base class. Following is an example:
Public Class BaseClass

Public intCounter As Integer 'Accessible anywhere
'Accessible only in this class or a derived class

Protected strName As String
...
End Class
Note The derived class is also known as a subclass, and the base class is
known as a superclass in Unified Modeling Language (UML) terminology.
Overriding and Overloading

Topic Objective
To explain how to override
and overload methods and
properties in a derived n Derived Class Can Override an Inherited Property or
class. Method
Lead-in
You may want to implement l Overridable – can be overridden
your own logic in a derived l MustOverride – must be overridden in derived class
class rather than use that of
the base class. This is l Overrides – replaces method from inherited class
called overriding. You can
also extend members of the l NotOverridable – cannot be overridden (default)
base class with the
Overload keyword. n Use Overload Keyword to Overload Inherited Property
or Method
When a derived class inherits from a base class, it inherits all the functions,
Delivery Tip
subroutines, and properties of the base class, including any implementation in
Point out that examples are
shown in the student notes the methods. Occasionally you may want to create implementation code
but that a fuller example will specific to your derived class rather than using the inherited methods. This is
be discussed on the next known as overriding. You can also overload methods defined in the base class
slide. with the Overloads keyword.
Overriding
Use the following keywords to create your own implementation code within a
derived class:
n Overridable
To create your own special implementation of the derived class, specify the
Overridable keyword in a base class member definition for a function,
subroutine, or property, as shown in the following example:
Public Overridable Sub OverrideMethod( )
MsgBox("Base Class OverrideMethod")
End Sub
n MustOverride
To create a base class member that must be overridden in all derived classes,
define the member with the MustOverride keyword. Only the member
prototype can be created in the base class, with no implementation code.
You can only use this keyword in a base class that is marked as
MustInherit. The following example shows how to define a method that
must be overridden:
Public MustOverride Sub PerformAction( )
MustOverride methods are useful in base classes because they allow you to
define baseline functionality without locking in implementation details that
can make them difficult to extend.
Module 5: Object-Oriented Pro gramming in Visual Basic .NET 35
n Overrides
To specify that a derived class method overrides the implementation of the
base class method, use the Overrides keyword. If the base class method that
is being overridden is not marked as Overridable, a compile-time error will
occur. The method signature must exactly match the method being
overridden, except for the parameter names. The following example shows
how to declare a derived class method that overrides the base class
implementation:
Public Overrides Sub OverrideMethod( )
MsgBox("Derived Class OverrideMethod")
End Sub
Note You can override methods by selecting (Overrides) in the Class Name
drop-down list in the IDE, and then selecting the method you want to
override.
n NotOverridable
Base class members without the Overridable keyword are, by default, not
overridable. However, if a base class member is marked as overridable, then
the member will be overridable in any derived classes based on the
immediate deriving class. To prevent this behavior, mark the overridden
method in the derived class as NotOverridable. This will stop subsequent
inheritance from overriding the method.
The following example shows how to declare a derived class method that
overrides the base class implementation but does not allow any further
overriding:
Public NotOverridable Overrides Sub OverrideMethod( )
MsgBox("Derived Class OverrideMethod")
End Sub
Overloading
You can create a method in a derived class that overloads a method defined in a
base class by using the Overloads keyword. Just as for overloading methods
within the same class, the method signatures must include different parameters
or parameter types. The following example shows how to overload a method
from a base class:
Public Overloads Sub Other(ByVal i As Integer)
MsgBox("Overloaded CannotOverride")
End Sub
Note that the base class method does not need to be marked as Overridable to
be overloaded.
Inheritance Example
Topic Objective Public
Public Class
Class BaseClass
BaseClass
To provide an example of Public
Public Overridable Sub
Overridable Sub OverrideMethod(
OverrideMethod( ))
inheritance. MsgBox("Base
MsgBox("Base OverrideMethod")
OverrideMethod")
End
End Sub
Lead-in Sub
Public
Public Sub
Sub Other(
Other( ))
Let’s look at a full example MsgBox("Base
MsgBox("Base Other
Other method
method –– not
not overridable")
of inheritance. End
overridable")
End Sub
Sub
End
End Class
Class
Public
Public Class
Class DerivedClass
DerivedClass
Inherits
Inherits BaseClass
BaseClass
Public
Public Overrides
Overrides Sub
Sub OverrideMethod(
OverrideMethod( ))
MsgBox("Derived
MsgBox("Derived OverrideMethod")
OverrideMethod")
End
End Sub
Sub
End
End Class
Class
Dim
Dim xx As
As DerivedClass
DerivedClass == New
New DerivedClass(
DerivedClass( ))
x.Other
x.Other 'Displays
'Displays "Base
"Base Other
Other method
method –– not
not overridable"
overridable"
x.OverrideMethod
x.OverrideMethod 'Displays
'Displays "Derived
"Derived OverrideMethod"
OverrideMethod"
There are three parts to this inheritance example:

n Code for the base class
Delivery Tip
This is an animated slide. It n Code for the derived class
begins by showing an n Code for the calling client
example of code for base
class. Click the slide to
reveal the following Base Class Code
sections:
The base class in the following example is specified as MustInherit. This
1. Derived class example
2. Client code example means that the class must be inherited from because it cannot be instantiated
directly.
Explain the example from
Public MustInherit Class BaseClass
the slide, and then look at
Public MustOverride Sub PerformAction( )
the examples in the notes.
End Sub
Public Sub Other( )

MsgBox("Base Other method – not overridable")
End Sub
End Class
The following table explains the methods used in the preceding code.
Method Declared as Description

PerformAction MustOverride Any implementation for this method must be
created in the deriving class.
OverrideMethod Overridable Any implementation for this method can be

overridden as a derived class.
Other NotOverridable Any implementation for this method cannot be
(by default) overridden in a derived class.
NotOverridable is the default for any method.
Derived Class Code

The derived class in the following example inherits from the base class. This
means that the class inherits all of the methods and properties of the base class.
Inherits BaseClass
Public NotOverridable Overrides Sub PerformAction( )

MsgBox("Derived PerformAction")
End Sub

End Sub
Public Overloads Sub Other(ByVal i As Integer)

MsgBox("Overloaded Other")
End Sub
End Class
Because the PerformAction method was marked as MustOverride in the base

class, it must be overridden in this derived class. This derived class also marks
the method as NotOverridable so that no other class can override this method
if DerivedClass is used as a base class for inheritance.
The method OverrideMethod is overridden in this derived class. Any calls to
OverrideMethod will result in the derived class implementation being
executed rather than the base class implementation.
The Other method cannot be overridden, but can be overloaded by the derived
class using the Overloads keyword.
Calling Code
The preceding example defines and instantiates a DerivedClass variable. The
following example shows how to call all the individual methods for the derived
class. The results are shown as comments in the code.
Dim x As DerivedClass = New DerivedClass( )

x.Other( ) 'Displays "Base Other method – not overridable"
x.Other(20) 'Displays "Overloaded Other"
x.OverrideMethod( ) 'Displays "Derived OverrideMethod"
x.PerformAction( ) 'Displays "Derived PerformAction"
Shadowing
Topic Objective
To describe the concept of
shadowing and explain how n Hides Base Class Members, Even If Overloaded
to shadow a method in a
Class
Class aBase
derived class. aBase
Public
Public Sub
Sub M1(
M1( )) 'Non-overridable
'Non-overridable by
by default
default
Lead-in ...
...
End
End Sub
Visual Basic .NET allows End
Sub
End Class
Class
you to shadow a method in Class
a derived class. Class aShadowed
aShadowed
Inherits
Inherits aBase
aBase
Public
Public Shadows
Shadows Sub
Sub M1(ByVal
M1(ByVal ii As
As Integer)
Integer)
'Clients
'Clients can
can only
only see
see this
this method
method
...
...
End
End Sub
Sub
End
End Class
Class
Dim
Dim xx As
As New
New aShadowed(
aShadowed( ))
x.M1(
x.M1( )) 'Generates
'Generates an
an error
error
x.M1(20)
x.M1(20) 'No
'No error
error
When a derived class inherits from a base class, it can either override a method
on the base class or shadow it. Overriding replaces the existing method based
on the method name and signature. Shadowing effectively hides the method in
the base class, based solely on the method name. This means shadowing a
method also hides any overloaded methods within the base class. You can
shadow a method regardless of whether the base method is specified as
overridable.
To learn how shadowing works, consider an example of a derived class that
shadows a method from the base class. The method in the base class has not
been specified as overridable.
The following example shows a base class that defines a single method called
M1. The derived class declares an M1 method that automatically shadows the
base class method and accepts a single argument. The client code can only
access the shadowed method that accepts the argument, and an error will be
generated if it attempts to access the base class method.
Class aBase
Public Sub M1( ) 'Non-overridable by default
...
End Sub
End Class
Class aShadowed
Inherits aBase
Public Shadows Sub M1(ByVal i As Integer)
'Clients can only see this method
...
End Sub
End Class
'Client Code
Dim x As New aShadowed( )
x.M1( ) 'Generates an error because method is hidden
x.M1(20) 'No error
Using the MyBase Keyword

Topic Objective
MyBase keywor d.
Lead-in n Refers to the Immediate Base Class
Sometimes you need to
access the base class from n Can Only Access Public, Protected, or Friend Members
a derived class.
of Base Class
n Is Not a Real Object (Cannot Be Stored in a Variable)
Public
Public Class
Class DerivedClass
DerivedClass
Inherits
Inherits BaseClass
BaseClass
Public
Public Overrides
Overrides Sub
Sub OverrideMethod(
OverrideMethod( ))
MyBase.OverrideMethod(
MyBase.OverrideMethod( ))
End
End Sub
Sub
End
End Class
Class
You can use the MyBase keyword to access the immediate base class from
which a derived class is inheriting. When using MyBase, you should be aware
of some limitations:
n It refers only to the immediate base class in the hierarchy. You cannot use
Delivery Tip MyBase to gain access to classes higher in the hierarchy.
Calling the constructor of a
base class is a common use n It allows access to all of the public, protected, or friend members of the base
of the MyBase keyword. class.
n It is not a real object, so you cannot assign MyBase to a variable.
If a derived class is overriding a method from a base class but you still want to
execute the code in the overridden method, you can use MyBase. This is a
common practice for constructors and destructors. The following example
shows how to use the MyBase keyword to execute a method as implemented in
the base class:
Inherits BaseClass
Public Sub New()
MyBase.New() 'Call the constructor of the base class
intValue = 1
End Sub
Public Overrides Sub OverrideMethod()
MyBase.OverrideMethod() 'Call the original method
End Sub
End Class
Using the MyClass Keyword

Topic Objective
MyClass keyword.
Lead-in n Ensures Base Class Gets Called, Not Derived Class
It is important that you call Public
Public Class
Class BaseClass
BaseClass
the correct class in Public
Public Overridable
Overridable Sub
Sub OverrideMethod(
OverrideMethod( ))
inheritance. The MyClass MsgBox("Base
OverrideMethod")
keyword can help you call End
End Sub
Sub
the right one. Public
Public Sub
Sub Other(
Other( ))
MyClass.OverrideMethod(
MyClass.OverrideMethod( ))'Will
'Will call
call above
above method
method
OverrideMethod(
OverrideMethod( )) 'Will
'Will call
call derived
derived method
method
End
End Sub
Sub
End
End Class
Class
Dim
Dim xx As
As DerivedClass
DerivedClass == New
New DerivedClass(
DerivedClass( ))
x.Other(
x.Other( ) )
You can use the MyClass keyword to ensure that a base class implementation
Delivery Tip
of an overridable method is called, rather than that of a derived class. When
Point out the important note
using MyClass, you should be aware of some limitations:
in the student notes
regarding the differences n It allows access to all of the public, protected, or friend members of the
between the MyClass and deriving class.
Me keywords.
n It is not a real object, so you cannot assign MyClass to a variable.
Example
The following example shows how to call a base class method from a derived
class by using the MyClass keyword:
Public Class BaseClass
End Sub
Public Sub Other( )

MyClass.OverrideMethod( ) 'Will call above method
End Sub
End Class

Inherits BaseClass
End Sub
End Class
Dim x As DerivedClass = New DerivedClass( )

x.Other( )
Output
The output from the execution of the preceding code is as follows:
Base OverrideMethod
Flow of Execution
The code in the example is executed as follows:
1. The Other method is called on the DerivedClass object, but because there
is no implemented code in the derived class, the base class code is executed.
2. When the MyClass.OverrideMethod call is executed, the
OverrideMethod subroutine is implemented in the base class.
3. Execution returns to the client code.
Important The Me keyword in previous versions of Visual Basic is not the

same as the MyClass keyword. The Me keyword has the same effect as if no
keyword were used. In the example in this topic, the derived class
implementation would be executed even if Me were used within the base class.
Demonstration: Inheritance
Topic Objective
To demonstrate class
inheritance.
Lead-in
This demonstration
examines how to create and
use class inheritance.
In this demonstration, you will see how to define a base class with a mixture of
Delivery Tip
overridable and non-overridable methods. You will see how to derive a class
The step-by-step
that inherits from the base class, and how to use the MyBase keyword.
module.
u Interfaces
Topic Objectiv e
lesson. n Defining Interfaces
Lead-in
In this lesson, you will learn n Achieving Polymorphism
about interfaces and
polymorphism.
In this lesson, you will learn how to use interfaces to achieve polymorphism.
Delivery Tip After completing this lesson, you will be able to:
This lesson assumes some
knowledge about interfaces n Define an interface by using the Interface keyword.
and polymorphism.
n Add member signatures that define the properties, methods, and events that
The topic is not covered your interface supports.
extensively because n Implement an interface by using the Implements keyword.
interfaces and
polymorphism are not new
to Visual Basic .NET. You
should ensure that students
are aware of additional
appropriate information.
Defining Interfaces
Topic Objective
To explain how to
create interfaces in n Interfaces Define Public Procedure, Property, and Event
Visual Basic .NET. Signatures
Lead-in n Use the Interface Keyword to Define an Interface Module
Interfaces are a new and
powerful feature of n Overload Members as for Classes
Visual Basic .NET. Interface
Interface IMyInterface
IMyInterface
Function
Function Method1(ByRef
Method1(ByRef ss AsAs String)
String) As
As Boolean
Boolean
Sub
Sub Method2(
Method2( ))
Sub
Sub Method2(ByVal
Method2(ByVal ii As
As Integer)
Integer)
End
End Interface
Interface
n Use the Inherits Keyword in an Interface to Inherit From
Other Interfaces
An interface defines signatures for procedures, properties, and events but

contains no implementation code. These signatures define the names of the
members, the parameter details, and the return values. Interfaces form a binding
contract between clients and a server. This contract enables a client application
to ensure that a class will always support particular member signatures or
functionality, and this aids in the versioning of components.
In Visual Basic 6.0, interfaces are created automatically whenever a public
Delivery Tip class is compiled as part of a COM component. This functionality works fine in
Check student
understanding of the most situations; however, you need to create a class in order to define an
concept of interfaces. Give a interface, which is not always necessary from a developer’s perspective.
brief review if necessary,
with a simple example of Visual Basic .NET introduces the Interface keyword, which allows you to
interfaces (such as the explicitly create an interface without creating a class. Interfaces can be defined
IPerson, Student, in the Declarations section of any module. This new approach creates a visible
Employee example used in distinction between a class and an interface, and this makes the concept clearer
the notes). for the developer.
You can use overloading when you define interfaces— just as you use it to
define classes— to create multiple versions of a member signature with different
parameters.
Example
The following example shows how to define an interface that includes three
method signatures, two of which are overloaded:
Interface IMyInterface
Function Method1(ByRef s As String) As Boolean
Sub Method2( )
Sub Method2(ByVal i As Integer)
End Interface
An interface can also inherit another interface if you use the Inherits keyword
before any member signatures are defined. If an interface is inherited from the
above example, it will contain all of the base interface signatures, in addition to
those defined in the new interface definition.
Achieving Polymorphism
Topic Objective
polymorphism in n Polymorphism
Visual Basic .NET.
l Many classes provide the same property or method
Lead-in
Visual Basic .NET combines l A caller does not need to know the type of class the
a traditional use of object is based on
interfaces— to create
polymorphism— with the n Two Approaches
new class inheritance
features. l Interfaces
Class implements members of interface
Same approach as in Visual Basic 6.0
l Inheritance
Derived class overrides members of base class
Polymorphism is achieved when multiple classes provide the same properties or

methods and the calling code does not need to know what type of class the
object is based on. This creates a form of reuse because you can write generic
client code to handle multiple types of classes without knowing about the
methods of each individual class. You can use two different approaches to
achieve polymorphism in Visual Basic .NET: interfaces and inheritance.
Delivery Tip Interfaces

The code shown in the
In Visual Basic 6.0, you can achieve polymorphism by creating an abstract
student notes is
demonstrated immediately class— with the sole purpose of defining an interface— and then implementing
after this topic. that interface in other classes by using the Implements keyword. This approach
allows multiple classes to share the same interface and allows classes to have
multiple interfaces.
In Visual Basic .NET, you do not need abstract classes to achieve
polymorphism. You can create interfaces explicitly by using a combination of
the Interface and Implements keywords.
Example
The following example shows how to implement polymorphism in
Visual Basic .NET. As you examine this code, note the following:
n The IPerson interface defines two member signatures: LastName and
Display.
n The Employee class implements the IPerson interface and both of its
members.
n By using the Implements keyword for each individual method, you can
specify your own name for the method and it will still be executed if a client
application requests the original name of the interface.
Interface IPerson 'IPerson interface definition

Property LastName( ) As String
Sub Display( )
End Interface
Class Employee 'Employee class definition

Implements IPerson 'Implements IPerson interface
Private strName As String
Private strCompany As String
'This method is public but also implements IPerson.Display

Public Sub Display( ) Implements IPerson.Display
MsgBox(LastName & " " & Company,, "Employee")
End Sub
'This property is private but implements IPerson.LastName

Private Property LastName( ) As String _
Implements IPerson.LastName
Get
Return strName
End Get
Set (ByVal Value As String)
...
End Property
Public Property Company( ) As String

...
End Property
End Class
Client Code Example

The following code shows how the Employee class and IPerson interface
Delivery Tip
could be used in a client application or within the same assembly as the class
Point out that the
p.Display( ) and and interface definitions.
emp.Display( ) methods n An Employee object is instantiated and details specific to the employee,
are actually the same call to such as the Company property, are assigned.
the Employee object, but by
means of different n An IPerson interface variable is then assigned to the Employee object to
interfaces. access methods that can only be accessed through the IPerson interface,
such as the LastName property.
n Both calls to the Display methods actually call the same code within the
Employee class, as shown in the previous example.
Dim perPerson As IPerson, empEmployee As New Employee( )

empEmployee.Company = "Microsoft"
perPerson = empEmployee
perPerson.LastName = "Jones"
perPerson.Display( ) 'Call the display method on the interface
empEmployee.Display( ) 'Display method is defined as public
Inheritance
Another way to ac hieve polymorphism with Visual Basic .NET is to use class
inheritance. A base class can be created that contains member signatures and
that optionally contains implementation code that can be inherited in a derived
class. The derived class must then override the individual methods with its own
implementation code, achieving unique functionality while retaining a common
method signature.
Note For more information about polymorphism, search for “Polymorphism”

in the Visual Studio .NET documentation.
Demonstration: Interfaces and Polymorphism

Topic Objective
To demonstrate how to use
interfaces to achieve
polymorphism.
Lead-in
This demonstration shows
how to use interfaces to
achieve polymorphism.
In this demonstration, you will learn how to create an interface and implement
Delivery Tip it to achieve polymorphism in two separate classes.
The step-by-step
module.
u Working with Classes

Topic Objective
lesson. n Using Shared Data Members
Lead-in
This lesson examines how n Using Shared Procedure Members
to work with classes in n Event Handling
Visual Basic .NET.
n What Are Delegates?
n Using Delegates
n Comparing Classes to Structures
In this lesson, you will learn how to work with classes. After completing this
lesson, you will be able to:
n Use shared data members to share data across class instances.
n Use shared procedure members.
n Define and handle class events.
n Use delegates in event handling.
n Describe how structures differ from classes.
Using Shared Data Members

Topic Objective
shared data members to n Allow Multiple Class Instances to Refer to a Single
share data across class Class-Level Variable Instance
instances. ClClaassss SavingsAccount
SavingsAccount
Lead-in PPubl
u b l ii cc Shared
Shared I Innt teerreessttRRaattee As A s Double
Double
PPubl
u b l iicc NName
a m e AAs s SString,
t r i n g , BBalance
a l a n c e AAs s DDouble
ouble
Shared data members allow
Sub
Sub New( ByVal strName A s S t r i n g , ByVal dblAmount
New( ByVal strName A s S t r i n g , ByVal dblAmount As
As Double)
data sharing for all Name
Double)
Name == strName
strName
instances of a class. Balance
Bal a n c e == dblAmount
dblAmount
End
End Sub Sub
PPubl
u b l ii cc F
F uunncctti ioonn Cal
Calccuul a
l at teeI Innt teer reesst t( ( ) ) AAss DDoouubbl lee
RRet etu
u rr nn B
Baallaannccee ** I Innt teer reesst tRRaat tee
End
End Functi Function on
End
End Class
Class
SavingsAccount
SavingsAccount. .I Innt teer reesst R t Raat e t e == 0.0030.003
Di
Di mm acct
acct1 1 AsAs New New SavingsAccount
SavingsAccount("Joe ("Joe Howard", Howard", 10000) 10000)
MMss g
gBBo
o xx (( a
a cc cc tt 11..C
Caallccuul laatteeI Innt teer reesst ,t , , , " I" nI nt et er er es ts t f of ro r " "& &a cacctc1t.1N. a
Nm e)
a me)
In Visual Basic 6.0, you can share data among objects by using a module file
and a global variable. This approach works, but there is no direct link between
Delivery Tip the objects and the data in the module file, and the data is available for anyone
to access.
Shared example code. Click In Visual Basic .NET, you can use shared data members to allow multiple
the slide to reveal an instances of a class to refer to a single instance of a class-level variable. You
example of client code.
can use shared members for counters or for any common data that is required
by all instances of a class.
An advantage of shared data members is that they are directly linked to the
class and can be declared as public or private. If you declare data members as
public, they are accessible to any code that can access the class. If you declare
the data members as private, provide public shared properties to access the
private shared property.
The following example shows how you can use a shared data member to
maintain interest rates for a savings account. The InterestRate data member of
the SavingsAccount class can be set globally regardless of how many instances
of the class are in use. This value is then used to calculate the interest on the
current balance.
Class SavingsAccount
Public Shared InterestRate As Double
Public Name As String, Balance As Double
Sub New(ByVal strName As String, _

ByVal dblAmount As Double)
Name = strName
Balance = dblAmount
End Sub
Public Function CalculateInterest( ) As Double

Return Balance * InterestRate
End Function
End Class
The following code shows how a client application can use the
SavingsAccount class in the previous example. As you examine this code, note
the following:
n The InterestRate can be set before and after any instances of the
SavingsAccount object are created.
n Any changes to the InterestRate will be seen by all instances of the
SavingsAccount class.
Sub Test( )
SavingsAccount.InterestRate = 0.003
Dim acct1 As New SavingsAccount("Joe Howard", 10000)

Dim acct2 As New SavingsAccount("Arlene Huff", 5000)
MsgBox(acct1.CalculateInterest, , "Interest for " & _

acct1.Name)
MsgBox(acct2.CalculateInterest, , "Interest for " & _
acct2.Name)
End Sub
The following example shows how to implement a public shared property for a
private shared data member:
Class SavingsAccount
Private Shared InterestRate As Double
Shared Property Rate( )

Get
Return InterestRate
End Get
Set(ByVal Value)
InterestRate = Value
End Set
End Property
The following code shows how a client application can use the shared property
in the previous example:
SavingsAccount.Rate = 0.003
Using Shared Procedure Members

Topic Objective
To explain shared
procedure members.
Lead-in n Share Procedures Without Declaring a Class Instance
You can create shared n Similar Functionality to Visual Basic 6.0 “Global”
procedure members that
allow you to call the method
Classes
without creating an instance n Can Only Access Shared Data
of the class.
'TestClass
'TestClass code
code
Public
Public Shared
Shared Function
Function GetComputerName(
GetComputerName( )) As
As String
String
...
...
End
End Function
Function
'Client
'Client code
code
MsgBox(TestClass.GetComputerName(
MsgBox(TestClass.GetComputerName( ))
))
You can use shared procedure members to design functions that can be called
Delivery Tip without creating an instance of the class. Shared procedures are particularly
Point out that this feature is
often used for library useful for creating library routines that other applications can easily access.
routines. This concept is similar to the GlobalMultiUse and GlobalSingleUse classes
used in Visual Basic 6.0.
As described in the previous topic, shared members can only access data that is
marked as Shared. For example, a shared method cannot access a module level
variable that is marked as either Dim, Private, or Public.
Example
The following example shows how a commonly used function, such as
GetComputerName, can be created as a shared procedure member so that a
client application can easily use it. The client only needs to reference the
method prefixed by the class name because no instance of the class is required.
'TestClass code
Public Shared Function GetComputerName( ) As String
...
End Function
'Client code
MsgBox(TestClass.GetComputerName( ))
Event Handling
Topic Objective
To introduce event-handling
options that are new in n Defining and Raising Events: Same As Visual Basic 6.0
Visual Basic .NET.
n WithEvents Keyword: Handles Events As in Visual Basic 6.0
Lead-in l In Visual Basic .NET, works with Handles keyword to specify
Visual Basic .NET provides method used to handle event
some powerful new event-
handling enhancements. n AddHandler Keyword: Allows Dynamic Connection to Events
Dim
Dim xx As
As New
New TestClass(
TestClass ( ),
), yy As
As New
New TestClass(
TestClass( ))
AddHandler
AddHandler x.anEvent,
x.anEvent, AddressOf
AddressOf HandleEvent
HandleEvent
AddHandler
AddHandler y.anEvent,
y.anEvent, AddressOf
AddressOf HandleEvent
HandleEvent
...
...
Sub
Sub HandleEvent(ByVal
HandleEvent(ByVal ii As
As Integer)
Integer)
...
...
End
End Sub
Sub
n RemoveHandler Keyword: Disconnects from Event Source
As a Visual Basic developer, you are familiar with creating events. However,
Visual Basic .NET provides powerful new event handling features with the
addition of the Handles, AddHandler and RemoveHandler keywords.
Defining and Raising Events

In Visual Basic .NET, you can define and raise events in the same way you do
in Visual Basic 6.0, by using the Event and RaiseEvent keywords.
Example
The following example shows how to define and raise an event:
'TestClass code
Public Event anEvent(ByVal i As Integer)
Public Sub DoAction( )

RaiseEvent anEvent(10)
End Sub
The WithEvents Keyword

You can use the WithEvents keyword in the same way that you used it in
Delivery Tip
The Handles keyword is Visual Basic 6.0. However, in Visual Basic .NET you also use the Handles
shown in the WithEvents keyword to spec ify which method will be used to handle an event. You can link
example in the student an event to any handler, whether it is the default handler or your own method.
notes. This approach allows you to link multiple events with a single method handler,
as long as the parameters match those of the events.
Example
The following example shows how you can use WithEvents in conjunction
with the new Handles keyword to link an event with a handler.
'Client code
Dim WithEvents x As TestClass
Dim WithEvents y As TestClass
Private Sub Button1_Cl ick(...) Handles Button1.Click

x = New TestClass( )
y = New TestClass( )
x.DoAction( )
y.DoAction( )
End Sub
Private Sub HandleEvent(ByVal x As Integer) _

Handles x.anEvent, y.anEvent
...
End Sub
The AddHandler Keyword

The new AddHandle r keyword allows you to dynamically connect to the
events of an object and handle them in any chosen method. This has some
advantages over the WithEvents keyword: the variable does not need to be
declared at the module level, and you can point multiple events from the same
object to a single handler method. You can also point events from multiple
objects to the same handler method by using the AddHandler keyword.
Syntax
The syntax for AddHandler is shown below.
AddHandler object.EventName, AddressOf methodName
Example
The following example shows a single method handler called HandleEvent
being used for two instances of TestClass:
Dim x As New TestClass( ), y As New TestClass( )
AddHandler x.anEvent, AddressOf HandleEvent

AddHandler y.anEvent, AddressOf HandleEvent
The RemoveHandler Keyword

The new RemoveHandler keyword disconnects your event handler from the
object’s events.
Syntax
The syntax for RemoveHandler is shown below.
RemoveHandler object.EventName, AddressOf methodName
Note AddressOf creates a reference to a procedure that can be passed to

appropriate methods. It was introduced in previous versions of Visual Basic.
For more information about AddressOf, search for “AddressOf” in the
Visual Studio .NET documentation.
Demonstration: Handling Events

Topic Objective
To demonstrate how to
define, raise, and handle
events.
Lead-in
Using events is a common
requirement for class
development.
In this demonstration, you will learn how to define and raise events in a class
Delivery Tip and how to handle them in client code.
The step-by-step
module.
What Are Delegates?

Topic Objective
To provide an introduction to
the concept and use of
delegates. n Objects That Call the Methods of Other Objects
Lead-in
Delegates are a powerful n Similar to Function Pointers in Visual C++
new feature of n Reference Type Based on the System.Delegate Class
Visual Basic .NET.
n Type-safe, Secure, Managed Objects
n Example:
l Useful as an intermediary between a calling procedure
and the procedure being called
The common language runtime supports objects called delegates that can call
the methods of other objects dynamically. Delegates are sometimes described
as type-safe function pointers because they are similar to the function
pointers used in other programming languages. Unlike function pointers,
Visual Basic .NET delegates are a reference type based on the class
System.Delegate and can reference both shared methods (methods that can be
called without a specific instance of a class) and instance methods. Delegates
provide the same flexibility as function pointers in Microsoft Visual C++ ®
without the risk of corrupted memory because they are type-safe, secure,
managed objects.
Delegates are useful when you need an intermediary between a calling
procedure and the procedure being called. For example, you might want an
object that raises events to be able to call different event handlers under
different circumstances. Unfortunately, the object raising events cannot
know ahead of time which event handler is handling a specific event.
Visual Basic .NET allows you to dynamically associate event handlers with
events by creating a delegate for you when you use the AddHandler statement.
At run time, the delegate forwards calls to the appropriate event handler.
Using Delegates
Topic Objective
To provide an example of
how to use delegates in
event handling. n Delegate Keyword Declares a Delegate and Defines
Lead-in Parameter and Return Types
Let’s look at an example of
how you can use delegates
in event handling. Delegate
Delegate Function
Function CompareFunc(
CompareFunc( __
ByVal
ByVal xx As
As Integer,
Integer, ByVal
ByVal yy As
As Integer)
Integer) As
As Boolean
Boolean
n Methods Must Have the Same Function Parameter and

Return Types
n Use Invoke Method of Delegate to Call Methods
You use the Delegate keyword to declare a delegate function signature that
defines the parameter and return types. Only methods that have the same
function parameter and return types can be used with a particular delegate
object.
Example
To learn how delegates work, consider an example that shows how to declare a
delegate function signature, create methods to accept the parameter types you
have defined, and call the functions by using the delegate object. The final part
of this example shows how to use the delegate to perform a bubble sort.
Declaring a Delegate Function Signature

The following code shows how to create a delegate function called
Delivery Tip CompareFunc, which takes two Integer parameters and returns a Boolean
This is an advanced feature
value.
of Visual Basic .NET. A
simple example is provided Delegate Function CompareFunc( _
in the notes. It is followed by
ByVal x As Integer, ByVal y As Integer) As Boolean
a more complex example.
Recommend that the Creating Methods

students look at the After you create a delegate, you can then create methods that accept the same
advanced example if they
parameter types, as follows:
are interested in this topic.
The example is also Function CompareAscending( _
included in the Demo Code ByVal x As Integer, ByVal y As Integer) As Boolean
folder. Return (y > x)
End Function
Function CompareDescending( _
ByVal x As Integer, ByVal y As Integer) As Boolean
Return (x > y)
End Function
Calling Methods
After you create the necessary functions, you can write a procedure to call these
two functions by using a delegate object as follows:
Sub SimpleTest( )
Dim delDelegate As CompareFunc
delDelegate = New CompareFunc(AddressOf CompareAscending)

MsgBox(delDelegate.Invoke(1, 2))
delDelegate = New CompareFunc(AddressOf CompareDescending)

MsgBox(delDelegate.Invoke(1, 2))
End Sub
Performing a Bubble Sort by Using Delegates

Now that you have created a delegate and defined its methods, you can start
using the delegate. A bubble sort routine is a good example of how you might
use delegates. This type of sort routine starts at the top of a list and compares
each item, moving it up the list if appropriate (bubbling it up), until the
complete list is sorted. The following method takes a sortType parameter that
will specify whether the sort should be ascending or descending. It also takes an
array of Integer values to be sorted. The appropriate delegate object is created,
depending on the order of the sort.
Sub BubbleSort(ByVal sortType As Integer, _
ByVal intArray( ) As Integer)
Dim I, J, Value, Temp As Integer
Dim delDelegate As CompareFunc
If sortType = 1 Then 'Create the appropriate delegate

delDelegate = New CompareFunc(AddressOf CompareAscending)
Else
delDelegate = New CompareFunc(AddressOf _
CompareDescending)
End If
For I = 0 To Ubound(intArray)
Value = intArray(I)
For J = I + 1 To Ubound(intArray)
If delDelegate.Invoke(intArray(J), Value) Then
intArray(I) = intArray(J)
intArray(J) = Value
Value = intArray(I)
End If
Next J
Next I
End Sub
The following code shows how to call the bubble sort procedure:
Sub TestSort( )
Dim a( ) As Integer = {4, 2, 5, 1, 3}
BubbleSort(1, a) 'Sort using 1 as ascending order

MsgBox(a(0) & a(1) & a(2) & a(3) & a(4), , "Ascending")
BubbleSort(2, a) 'Sort using 2 as descending order

MsgBox(a(0) & a(1) & a(2) & a(3) & a(4), , "Descending")
End Sub
Comparing Classes to Structures

Topic Objective
To explain the differences
between classes and
structures.
Classes Structures
Lead-in
Classes and structures have Can define data members, Can define data members,
similar functionality, but properties, and methods properties, and methods
classes provide a more Supports constructors and No default constructor or
powerful basis for object- member initialization member initialization
oriented dev elopment.
Support Finalize method Do not support Finalize method;
implement IDisposable
Extensible by inheritance Do not support inheritance
Reference type Value type
Classes and structures are similar in several ways: both can define data
members, properties, and methods. However, classes provide some advanced
features that developers can use.
Classes Structures
Initialization Supports constructors and member No default constructor and no initialization of

initialization. members.
Finalize method Support Finalize method. Do not support Finalize method. You must manually
release resources.. Structures can use interfaces, so
they can use the IDispose interface to implement the
Dispose method to release resources.
Inheritance Extensible by inheritance. Do not support inheritance.
Data type Reference data type. Value data type.
When an object variable is passed to When a structure variable is passed to a function, the
a function, the address reference of actual data must be copied to the function.
the data is passed rather than the Assigning one structure variable to another creates an
data itself. actual copy of the structure. Updates to one of the
Assigning one class variable to variables will therefore not affect the other.
another points both variables to the The difference in data type has a significant effect on
same object. Any updates to either application performance. A class with a lot of internal
variable will therefore affect the data will perform better than a large data structure
other. under these conditions.
Lab 5.2: Inheriting the Package Class

Topic Objective
To introduce the lab.
Lead-in
In this lab, you will create a
base class and a class that
derives from it.
Explain the lab objectives.

Objectives
After completing this lab, you will be able to:
n Create base classes.
n Create derived classes that use inheritance.
n Use inherited classes from calling code.
Prerequisites
Before working on this lab, you should be familiar with inheritance in
Visual Basic .NET.
Scenario
In this lab, you will continue creating the Cargo system. You will create the
Package base class, the SpecialPackage derived class, and the test application.
Some of the code has been created for you.
Starter and Solution Files

There are starter and solution files associated with this lab. The starter files are
in the install folder\Labs\Lab052\Starter folder, and the solution files are in the
install folder\Labs\Lab052\Solution folder.
Estimated time to complete this lab: 60 minutes

Exercise 1
Completing the SpecialPackage Class
In this exercise, you will examine the pre-written Package class and complete
the partially written SpecialPackage class. You will inherit from the Package
class, and override some of its methods.
å To open the starter project

1. Open Visual Studio .NET.
2. On the File menu, point to Open, and click Project . Set the folder location
to install folder\Labs\Lab052\Starter, click Lab052.sln, and then click
Open.
å To examine the Package class

1. Open the Package.vb class.
2. Examine the existing properties and methods.
The Package class retrieves and stores information about a single package
that will be delivered to a customer. It contains information about the
package, including a description, size dimensions, instructions, weight, and
value. These properties have been created for you.
The Package class provides methods to simulate the creation, retrieval, and
deletion of package information. These methods are marked as overridable
for inheriting classes. Note that the IsSpecialPackage method is marked as
shared so that it can be accessed without instantiating object variables.
These methods have been created for you.
å To examine the SpecialPackage class

1. Open the SpecialPackage.vb class.
2. Examine the existing properties.
å To inherit from the Package class

1. At the top of the SpecialPackage class, locate the list of private variables.
Insert the following line immediately before the variable declarations:
Inherits Package
This will create the relationship between the Package base class and the
derived class SpecialPackage.
2. Add the following methods to the SpecialPackage class definition:

Method name Type Parameters
GetDetails Public Overrides ByVal intID As Integer
Sub
CreatePackage Public Overloads ByVal intDeliveryID As

Function Integer
ByVal strDescription As
String
ByVal strDimensions As
String
ByVal strInstructions As
String
ByVal strWeight As String
ByVal dblValue As Double
ByVal blnOxygen As Boolean
ByVal strTemperature As
String
ByVal strTimeLimit As
String
ByVal strExtra As String
<RETURN VALUE> As Integer
DeletePackage Public Overrides ByVal intID As Integer

Sub
å To implement the GetDetails method

1. Locate the GetDetails method declaration and add code to call the
MyBase.GetDetails method, passing the intID as the parameter to retrieve
the simulated Package details.
2. After the call to MyBase.GetDetails, assign the following values to the
SpecialPackage properties to simulate a returned record from the database:
Property Value
OxygenRequired True
Temperature 80
TimeLimit 5 hours
ExtraInstructions Feed if time limit exceeded
å To implement the CreatePackage method

1. Locate the CreatePackage method declaration, and add code to call the
MyBase.CreatePackage method, passing in the following values as the
parameters to create the simulated Package record.
Parameter Name Value
intDeliveryID intDeliveryID
strDescription strDescription
strDimensions strDimensions
strInstructions strInstructions
strWeight strWeight
dblValue dblValue
2. After the call to MyBase.CreatePackage, assign the following values to the

SpecialPackage properties to simulate the update to the database.
Property Value
OxygenRequired blnOxygen
Temperature strTemperature
TimeLimit strTimeLimit
ExtraInstructions strExtra
3. After the property value assignments, use the MsgBox function to display
the message “Special instructions added”.
4. Return the PackageID as the return value of the CreatePackage method.
å To implement the DeletePackage method

1. Locate the DeletePackage method declaration, and insert code to use the
MsgBox function to display the message “Deleting special package details”
to simulate the deletion of the SpecialPackage database record.
2. After the displaying the message, call the MyBase.DeletePackage method,
passing intID as the parameter, to simulate the deletion of the Package
record.
Exercise 2
Retrieving Packages
In this exercise, you will write the calling code for the Retrieve button that
calls either a Package or a SpecialPackage object. You will then test your code
by entering some values into the Package form.
å To create the Retrieve button code

1. Open frmPackage in the Code Editor, and locate the btnRetrieve_Click
event procedure.
2. Create an If statement that calls the Package.IsSpecialPackage shared
function, passing in the Text property of txtID as the parameter. (Use the
CInt function to convert the text value into an Integer.)
å To use a SpecialPackage object

1. In the true part of the If statement, declare and instantiate a SpecialPackage
variable called aSpecial.
2. Set the Checked property of chkSpecial to True.
3. Call the GetDetails method of the aSpecial object, passing in the Text
property of txtID as the parameter. (Use the CInt function to convert the
text value into an Integer.)
4. Display the properties of the aSpecial object in the appropriate text boxes.
Use the information in the following table to assign the text box values to
the properties of the aSpecial object.
Control Property of aSpecial
txtDeliveryID.Text DeliveryID
txtDescription.Text Description
txtDimensions.Text Dimensions
txtInstructions.Text Instructions
txtValue.Text Value
txtWeight.Text Weight
txtExtra.Text ExtraInstructions
txtTemperature.Text Temperature
txtTimeLimit.Text TimeLimit
chkOxygen.Checked OxygenRequired
å To use the Package object

1. In the false block of the If statement, set the Checked property of
chkSpecial to False, and declare and instantiate a Package variable called
aPackage.
2. Call the GetDetails method of the aPackage object, passing in the Text
3. Display the properties of the aPackage object in the appropriate textboxes.
Use the information in the following table to assign the text box values to
the properties of the aPackage object.
Control Property of aPackage
txtDeliveryID.Text DeliveryID
txtDescriptio n.Text Description
txtDimensions.Text Dimensions
txtInstructions.Text Instructions
txtValue.Text Value
txtWeight.Text Weight
txtExtra.Text “”
txtTemperature.Text “”
txtTimeLimit.Text “”
chkOxygen.Checked False
å To test the Re trieve button code

1. Set a breakpoint on the first line of the btnRetrieve_Click procedure. From
the Debug menu, click Start .
2. Enter the value 18 in the PackageID box, click the Retrieve button, and
then step through the procedure.
3. Confirm that your code retrieves the package information and displays it
correctly in the text boxes.
4. Click the Clear Data button to reset the information.
5. Enter the value 33 in the PackageID box, click the Retrieve button, and
step through the procedure.
6. Confirm that your code retrieves the special package information and
displays it correctly in the text boxes.
btnRetrieve_Click.
Exercise 3
Creating Packages
In this exercise, you will write the calling code for the New button that creates
either a Package or SpecialPackage object. You will then test your code by
entering some values into the Package form.
å To create the New Package button code

1. Locate the btnNew_Click event procedure.
2. Create an If statement that checks the Checked property of the chkSpecial
check box.
å To create a Package object

1. In the false part of the If statement, declare and instantiate a Package
variable called aPackage.
2. Call the CreatePackage method of the aPackage object, passing in the
following values as parameters.
Parameter TextBox
iDelivery CInt(txtDeliveryID.Text)
strDescription txtDescription.Text
strDimensions txtDimensions.Text
strInstructions txtInstructions.Text
strWeight txtWeight.Text
dblValue CDbl(txtValue.Text)
3. Store the return of the CreatePackage method in the Text property of the
txtID box. (Use the CStr function to convert the Integer to a String.)
å To create a SpecialPackage object

2. Call the overloaded CreatePackage method of the aPackage object,
passing in the following values as parameters.
Parameter Value
iDelivery Cint(txtDeliveryID.Text)
strDescription txtDescription.Text
strDimensions txtDimensions.Text
strInstructions txtInstructions.Text
strWeight txtWeight.Text
dblValue CDbl(txtValue.Text)
blnOxygen chkOxygen.Checked
strTemperature txtTemperature.Text
strTimeLimit txtTimeLimit.Text
strExtra txtExtra.Text
3. Store the return of the overloaded CreatePackage method in the Text

property of the txtID box. (Use the CStr function to convert the Integer to a
String.)
å To test the standard Package code

1. Set a breakpoint on the first line of the btnNew_Click procedure.
2. On the Debug menu, click Start.
3. Enter the following values.
Control Value
DeliveryID 11
Description Software
Instructions None
Dimensions NA
Weight NA
Value 50
4. Click the New button, and step through the procedure.

5. Confirm that the code correctly passes the values to the package class.
6. Click the Clear Data button.
å To test the SpecialPackage code

1. Enter the following values.
Control Value
DeliveryID 43
Description Heart Transplant
Instructions Deliver to Joe Howard
Dimensions NA
Weight NA
Value 0
SpecialPackage checkbox Checked
ExtraInstructions Speed is essential
OxygenRequired checkbox Unchecked
Temperature 20
TimeLimit 2 hours
2. Click the New button, and debug the procedure.

3. Confirm that the code passes the values to the SpecialPackage class
correctly.
4. Click the Close button to quit the application, and remove the breakpoint on
btnNew_Click.
Exercise 4
Deleting Packages
In this exercise, you will write the calling code for the Delete button that
deletes either a Package or SpecialPackage object. You will then test your
code by entering some values into the Package form.
å To create the Delete button code

1. Locate the btnDelete_Click event procedure.
2. Create an If statement that calls the Package.IsSpecialPackage shared
function, passing in the Text property of txtID as the parameter. (Use the
CInt function to convert the text value into an Integer.)
å To delete a SpecialPackage object

variable called aSpecial.
2. Call the DeletePack age method of the aSpecial object, passing in the Text
å To delete a Package object

1. In the false part of the If statement, declare and instantiate a Package
2. Call the DeletePackage method of the aPackage object, passing in the Text
å To test the Delete button code

1. Set a breakpoint on the first line of the btnDelete_Click procedure, and, on
the Debug menu, click Start .
2. Enter the value 18 in the PackageID text box, and click the Delete button to
debug the procedure.
3. Confirm that your code simulates the deletion of the Package object.
4. Click the Clear Data button to reset the information.
5. Enter the value 33 in the PackageID text box, and click the Delete button to
debug the procedure.
6. Confirm that your code simulates the deletion of the SpecialPackage object.
7. Click the Close button to quit the application, and remove the breakpoint on
btnDelete_Click.
8. Close Visual Studio .NET.
Review
Topic Objective
To reinforce module
objectives by reviewing key
points. n Defining Classes
Lead-in
The review questions cover n Creating and Destroying Objects
some of the key concepts n Inheritance
taught in the module.
n Interfaces
1. Create code that defines multiple constructors for a Person class. The first
constructor will not take any arguments. The second will take two string
values: FirstName and LastName.
Class Person
Sub New( )
'Default constructor
End Sub
Sub New(ByVal FirstName As String, _
ByVal LastName As String)
'Second constructor
End Sub
End Class
2. Garbage collection occurs immediately after all references to an object are

removed. True or false? If false, explain why.
False. Garbage collection may happen at any time after all object
references have been removed.
3. Describe the functionality of the MyBase keyword.

MyBase is used in a derived class to access methods and properties in
the immediate base class.
4. What is a potential problem that may result from the following class code
sample? How can you rewrite the code to resolve the problem?
Class Person
Private Sub Save( )
'Save the local data in a database
End Sub
Sub Dispose( )
Save( )
End Sub

Dispose( )
MyBase.Finalize( )
End Sub
End Class
The Dispose method can be called directly from a client and might be
called again when the object is destroyed by garbage collection. This
would result in the Save method being called twice, which may create
data inconsistencies.
To avoid this, use the SuppressFinalize method of the GC class to stop
the Finalize method being called after Dispose. Add the line
"GC.SuppressFinalize()" in the Dispose method after the Save line as
follows):
Sub Dispose()
Save()
GC.SuppressFinalize()
End Sub
5. You can create an interface explicitly in Visual Basic .NET. True or false?
If false, explain why.
True. You can create an interface explicitly by using the
Interface…End Interface statement block.
6. Will the following code compile correctly? If not, why?

Class Person
Event NameChanged( )
Private strName As String
Sub ChangeName(ByVal strNewName As String)

strName = strNewName
RaiseEvent NameChanged( )
End Sub
End Class
Module TestCode
Sub Main( )
Dim x As New Person( )
AddHandler x.NameChanged, AddressOf HandleIt
x.ChangeName("Jeff")
End Sub
Sub HandleIt(ByVal strValue As String)

MsgBox(strValue)
End Sub
End Module
The code will not compile correctly because the signature of the event
does not match the signature of the delegate in the AddHandler
statement.

Module 5 - Object-Oriented Programming in Visual Basic

Uploaded by

Module 5 - Object-Oriented Programming in Visual Basic

Uploaded by

Module 5: Object-

This course is based on the prerelease version (Beta 2) of Microsoft® Visual

© 2001 Microsoft Corporation. All rights reserved.

Materials and Preparation

å To test the New Employee code

å To test the Existing Employee code

å To test the Improved New Employee code

å To test the project

Interfaces and Polymorphism

å To test the application

å To test the events

In this module, you will learn how to implement object-oriented programming

Procedure for Defining a Class

Create a Destructor, If Appropriate

Declare Methods and Events

Using Access Modifiers

Public Accessible everywhere.

Note Inheritance in Visual Basic .NET is described in detail in the Inheritance

Public Sub TestIt(ByVal x As Integer)

Public Function GetIt( ) As Integer

n ReadOnly, WriteOnly, and Default Keywords

The syntax for declaring class properties has changed significantly in

Public Property MyData( ) As Integer

Using Read-Only Properties

Using Write-Only Properties

Using Default Properties

You can use attributes to provide extra information or metadata to the

Functionality is provided by the Microsoft .NET Framework to allow you to

n Specified Parameters Determine Which Method to Call

Overloading is a powerful object-oriented feature that allows multiple methods

Note Overloading a method from an inherited class will be discussed in the

Public Function Display(s As String) As String

Public Function Display(i As Integer) As Integer

n Can Overload, But Does Not Use Overloads Keyword

Using Sub New

Public Sub New(ByVal i As Integer)

Public Sub New(ByVal i As Integer, _

In Visual Basic 6.0, the Class_Terminate event runs when an object is no

u Creating and Destroying Objects

Instantiating and Initializing Objects

Delivery Tip Example 1

Visual Basic 6.0

Visual Basic .NET

In previous versions of Visual Basic, object destruction is based on a reference

It is important to note that garbage collection introduces a time delay between

It is possible to attempt to force the collection of unused objects by using the

However, using the Collect method is not recommended because forcing

Using the Dispose Method

n Call the Dispose Method from Client Code

Protected Overrides Sub Finalize( )

The IDisposable Interface

Protected Overrides Sub Finalize( )

Demonstration: Creating Classes

Lab 5.1: Creating the Customer Class

Explain the lab objectives.

Starter and Solution Files

Estimated time to complete this lab: 45 minutes

å To open the starter project

å To create the Customer class

å To define the class properties

3. Save the project.

å To define the class methods

AddCustomer Public Function ByVal strEmail As String

New Public Sub <None>

New Public Sub ByVal intID As Integer

å To complete the class constructors

å To create the Logon button code

5. Set cusCustomer to Nothing.

å To test the LogOn code

3. Click the Logon button, and step through the procedure.

6. Click the Logon button, and step through the procedure.

å To create the Retrieve button code

4. Save the project.

å To test the Retrieve code

å To create the Add Customer button code

4. Save the project.