Course Description

This 3-day Visual Basic Fundamentals training course provides a sound, hands-on introduction to the fundamentals of the Visual Basic programming language as well as an understanding of the structure and operation of the Microsoft.NET programming platform. After completing this course, students will be able to:

  • Use Visual Studio and the Visual Basic language to build and test .NET applications
  • Understand and use the fundamental aspects of the Visual Basic language including data types, variables, operators and flow control
  • Create and consume classes and objects
  • Work with data structures such as arrays and collection classes
  • Understand and use generics, exception handling techniques, delegates and events

While this course is current to VS2010, it is suitable for users of earlier or more recent releases of Microsoft.NET and Visual Studio.


Some experience with programming is recommended.

Who is this Course For?

This course is for newcomers to Microsoft.NET, Visual Studio and Visual Basic.  It is suitable for Solution Architects, Software Testers and any  other IT Practitioner who needs to understand and use Visual Basic at a level that does not call for an in-depth knowledge of the language.  This course is not intended for professional application software developers and designers.

Further Training

A more in-depth exposure toi Visual Basic and Microsoft.NET can be gained through attendance at our Visual Basic Programming Introduction training course and our Visual Basic Programming Advanced training course.

Course Content

Getting Started with .NET

What is .NET?
Why .NET?
Advantages of .NET
.NET Architecture
Examining a .NET Application
Introducing Assemblies
Types of Programs
Command-Line Compiler
Microsoft Intermediate Language (MSIL)
Using Visual Studio 2010
Visual Studio Profile Settings
A .NET Console Application
Debugging & Handling Exceptions
Handling Errors
Fixing Logic Errors

Data Types and Variables

Introducing Variables & Data Types
Data Types
Integer, Floating-Point, Decimal Types
Char, String, Bool Types
Object Data Type
Constants, Enumerations & Structures
Converting between Data Types

Using the .NET Framework

Using .NET Framework Classes
Generating Random Numbers
Getting Information about the Computer
Working with XML
File Input & Output
Working with Strings
Fields & Properties of the String Class
Methods of the String Class
Formatting Strings
Using the StringBuilder Class
Working with Dates & Times
Properties of the DateTime Structure
Methods of the DateTime Structure
Using the TimeSpan Structure

Branching and Flow Control

Branching in Code
Conditional Branching
Repeating Code Blocks
Unbounded Looping
Looping a Specific Number of Times
The foreach Loop
Unconditional Branching
The break Statement
The goto Statement
The continue Statement

Classes & Objects
Introducing Classes and Objects
Using Class Properties
Calling Class Methods
Creating Your Own Classes
Adding XML Comments
Class View Window in Visual Studio
Class Designer
Adding Code
Adding Methods
Object Test Bench
Working with Classes
Value Types vs. Reference Types
Nulling Reference Variables & Disposing
Deterministic Finalisation
Overriding Object Class Functionality
Manipulating Object References
Instance vs. Static Members

Properties and Methods

Overview of Properties & Methods
Calculating Values for Properties
Validating Values in Properties
Passing Arguments to Methods
Methods in Classes
Class Constructors
Saving & Retrieving Information
Returning & Passing Arrays
Instance & Static Members

Object-Oriented Techniques

Derived Classes
Abstract Classes & Members
Sealed Classes & Members
Implementing an Interface
Interfaces in the .NET Framework
Organising Classes
Partial Classes
Nested Classes

Working with Arrays

Introducing Arrays
Creating & Filling Arrays
Initialising Arrays
Retrieving Data from Arrays
Arrays and Method Parameters
Arrays in the .NET Framework
Manipulating Arrays
Sorting Arrays
Searching in Arrays
Creating Indexers
Adding an Enumerator

Delegates and Events

Motivating Delegates
Using an Event Interface Class
Introducing Delegates
Named vs. Anonymous Delegates
Delegate vs. MultiCast Delegate
Working with Events
Declaring and Raising Events
Multiple Event Handlers
Exceptions & Multiple Event Handlers
Manually Invoking each Listener
Using the .NET Event Design Pattern


Generic Methods
Generic Classes
Advantages of Generics
Generics & Arrays
Sorting Arrays
Using IComparer Interface
Sorting with Generic Comparisons
Searching with Generic Predicates
Generic Interfaces
Generic Constraints
Generics & Lists
Collection Storing using ArrayList
Collection Storing using a Generic List
Sorting with the List Class

Handling Exceptions

Perspectives on Exception-Handling
Exception-Handling in .NET
No Error Handling
Adding a Simple try/catch Block
Unhandled Exceptions
Using an Exception Object
Catching Specific Exceptions
The Exception Hierarchy
Raising Errors
Using the throw Keyword
Exception-Handling Options
Passing Error Information
Running Code Unconditionally
The finally Block
Cleaning Up – the using Statement
Creating Exception Classes

Collection Classes

Generics, Collections & Interfaces
The Generic Collection Interface
Working with The List Class
Working with Predicates
Dictionaries, Stacks & Queues
Storing Key/Value Pairs in a Dictionary
SortedDictionary & SortedList Classes
Using Queues & Stacks
Creating Custom Generic Collection Classes
Consuming the Custom Collection Class


Introduction to LINQ
LINQ data providers
LINQ to Objects