About this Tutorial –

Objectives –

Delegates will learn to develop web applications using VB 4.0. After completing this course, delegates will be able to:

  • Use Visual Studio 2012 effectively
  • Object Orientation with VB using Visual Studio 2012


This course has been designed primarily for programmers new to the .Net development platform. Delegates experience solely in Windows application development or earlier versions of ASP.Net will also find the content beneficial.


Before attending this workshop, students must:

  • Be able to manage a solution environment using the Visual Studio 2012 IDE and tools
  • Be able to program an application using a .NET Framework 4.0 compliant language


Copyright 20/12/12 – David Ringsell

Download Solutions

Java tutorial

Lab 1 – Classes and Objects

  1. Open Visual Studio 2012 and create a new Visual Basic Console Application:
      • Select the File menu, then select New Project OR (CTRL+Shift+N).
      • On the left menu, Expand Templates then expand Visual Basic and select
      • Choose Console Application.
      • Name the project Date.
      • Name the Solution DateTester.
      • Browse to the place on your computer where you wish Visual Studio
        to create the directory for your solution (keeping the tick box, “Create Directory For Solution”, selected ) or leave the default location.
      • Click Ok

    Visual Studio 2012 VB Windows Console Project

    • Right-click on the project name: Date.
    • Select Add then select Module (Or Ctrl+Shift+A) and call it DateModule.vb.
  2. Define a class called MyDate in the project. Add a constructor and also define a method called DisplayDate() in the class.
  3. Add three properties for the year, month, day, to the MyDate class.
  4. Add a second overloaded constructor to the MyDate class. This will initiate the month and days properties only in the class, the year will default to the current year.

    Public Class MyDate
    ’Year defaulted to current yearPublic Property Year As Integer = Now.Year
    Public Property Month As String
    Public Property Day As Integer’Constructor
    Public Sub New(ByVal intYear As Integer, ByVal strMonth As String, ByVal intDay As Integer)
    Year = intYear
    Month = strMonth
    Day = intDay
    End Sub’Overloaded Constructed
    Public Sub New(ByVal strMonth As String, ByVal intDay As Integer)
    Month = strMonth
    Day = intDay
    End Sub
    ’A method to display the date
    Public Sub DisplayDate()
    Console.WriteLine(String.Format(“The Date is: {0} {1} {2}”,
    Day.ToString(), Month, Year.ToString()))
    End Sub
    End Class

  5. View code file.
  6. Create a tester using VB Module:
    • Double click on Module1.vb
    • Create a new class inside Module1: create an oDate object from the MyDate class, in the console application.
      ‘Create an instance of the date object
      Dim oDate As MyDate = New MyDate(2005, “March”, 14)
    • Test the methods and properties of the oDate object.
      ‘Change the property values in oDate
      oDate.Year = 2013
      oDate.Month = “September”
      oDate.Day = 21
      ‘And then display them
    • Run your application:
    • View code file.


Lab 2 – Inside Methods

  1. Add a GetDate method with ref parameters for year, month, day, to the MyDate class created in Lab 1.
  2. Note: the difference between a Sub and a Function is that a Function can return a value.
  3. Add code to GetDate() to return valid parameters for year, month, day.
    ‘Sending parameters by reference – A method to return the date
    Public Function GetDate(ByRef intDay As Integer, ByRef strMonth As String, ByRef intYear As Integer) As String
    Day = intDay
    Month = strMonth
    Year = intYear
    Return (String.Format(“The Date is: {0} {1} {2}”, Day.ToString(),
    Month, Year.ToString()))
    End Function
  4. Test the method by calling it, then displaying the returned year, month, day values.
    Dim intDay As Integer = 0
    Dim strMonth As String = “”
    Dim intYear As Integer = 0‘Display the values in the first date object using the GetDate method
    Console.WriteLine(oDate.GetDate(intDay, strMonth, intYear))
    ‘Show how the GetDate method has changed the local variables by using ref
    Console.WriteLine(“The Date is: ” + intDay.ToString()
    + ” ” + strMonth + ” ” + intYear.ToString())
  5. Run your application:
    Date - Inside method
  6. View code file.

Lab 3 – Debugging

For all remaining lab exercises throughout this course, examine and debug your code by:

  1. Setting breakpoints in lines of code by clicking in the margin. When run the code will pause at the first beakpoint.
  2. Stepping through lines of code when a breakpoint is hit by pressing F11. The code will execute line by line. Hover the mouse pointer over a variable to show its current value.
  3. Using these debug windows to understand and fix code:
    • Watch
    • Locals
    • Immediate
    • Call Stack
  4. Debug windows are available only when the code is paused in break mode. Use the Debug>Windows command to show them.

Lab 4 – Inheritance

  1. Open Visual Studio and create a new VB Console Application. (Same as Lab 1 > first point). The Solution name and the project name is Inheritance
  2. Define a class called Control, with a constructor and a DrawControl() method.
  3. Add only a Console.Write() statement to the DrawControl() method.
    Public Class Control
    ’These members are private and thus invisible
    ’to derived class methods we’ll examine this
    ’later in the chapter
    Private top As Integer
    Private left As Integer’Constructor takes two integers to
    ’fix location on the console
    Public Sub New(ByVal top As Integer, ByVal left As Integer)
    Me.top = top
    Me.left = left
    End Sub’Simulates drawing the control
    Public Overridable Sub DrawControl()
    Console.WriteLine(“Drawing Control at {0}, {1}”, top, left)
    End Sub
    End Class
  4. Create a class called TextBox that inherits from Control, but replaces the DrawControl method. Change the Console.Write() statement to show a different message.
    ‘TextBox derives from Control
    Public Class TextBox
    Inherits Control
    Private mTextBoxContents As String ‘New member variable’Constructor adds a parameter
    Public Sub New(ByVal top As Integer, ByVal left As Integer, ByVal theContents As String)
    MyBase.New(top, left) ‘ call base constructor
    mTextBoxContents = theContents
    End Sub
    ’A new version (note keyword) because in the
    ’Derived method we change the behavior
    Public Overrides Sub DrawControl()
    MyBase.DrawControl() ‘Invoke the base method
    Console.WriteLine(“Writing string to the textbox: {0}”, mTextBoxContents)
    End Sub
    End Class
  5. Test the TextBox class by calling its DrawControl method.
    ‘Create a base instance
    Dim contr As Control = New Control(5, 10)
    ‘Create a derived instance
    Dim txt As TextBox = New TextBox(20,
    30, “Hello world”)
  6. Run your application:
  7. View code file.

Lab 5 – Operator Overloading

      1. Open Visual Studio and create a new VB Console Application. (Same as Lab 1 > first point). The Solution name and the project name is Fraction
      2. Define a class called Fraction, with a constructor and a ToString() method.
      3. Add two integer field to the class to hold the numerator and the denominator.
      4. Add a constructor to initialize the numerator and the denominator.
      5. Create a subtraction operator (-) using operator overloading.
        Public Class Fraction
        Private numerator As Integer
        Private denominator As Integer
        ’Create a fraction by passing in the numerator
        ’and denominator
        Public Sub New(ByVal numerator As Integer,
        ByVal denominator As Integer)
        Me.numerator = numerator
        Me.denominator = denominator
        End Sub
        ’Overloaded operator- takes two fractions
        ’and returns their sum
        Public Shared Operator -(ByVal lhs As Fraction,
        ByVal rhs As Fraction) As Fraction
        Dim firstProduct As Integer = 0
        Dim secondProduct As Integer = 0
        ’Like fractions (shared denominator) can be added
        ’by adding thier numerators
        If (lhs.denominator = rhs.denominator) Then
        Return New Fraction(lhs.numerator – rhs.numerator,
        End If
        ’Simplistic solution for unlike fractions
        firstProduct = (lhs.numerator * rhs.denominator)
        &nbsp- (rhs.numerator * lhs.denominator)
        secondProduct = lhs.denominator * rhs.denominator
        Return New Fraction(firstProduct, secondProduct)
        End Operator
        ’Return a string representation of the fraction
        Public Overrides Function ToString() As String
        Dim s As String = numerator.ToString() + “/”
        + denominator.ToString()
        Return s
        End Function
        End Class
      6. Test your class
        Public Class Tester
        Public Sub Run()
        Dim f1 As Fraction = New Fraction(1, 2)
        Console.WriteLine(“f1: {0}”, f1.ToString())
        Dim f2 As Fraction = New Fraction(1, 6)
        Console.WriteLine(“f2: {0}”, f2.ToString())
        Dim f3 As Fraction = f1 – f2
        Console.WriteLine(“f1 – f2 = f3: {0}”, f3.ToString())
        End Sub
        End Class
      7. Run your application:
      8. View code file.

Lab 6 – Structs
Create a Structure to hold colour values. Use the Structure in code.

      1. Open Visual Studio and create a new VB Console Application. (Same as Lab 1 > first point). The Solution name and the project name is VBColors
      2. Define a structure called Colour, with a constructor and a ToString() method.
      3. Add three integer properties to represent the red, green and blue component of the colour.
        ‘declare a struct named Colour
        Public Structure Colour
        Public Property Red As Integer
        Public Property Green As Integer
        Public Property Blue As Integer
        Public Sub New(ByVal rVal As Integer, ByVal gVal As Integer, ByVal bVal As Integer)
        Red = rVal
        Green = gVal
        Blue = bVal
        End Sub
        ’Display the Struct as a String
        Public Overrides Function ToString() As String
        Return String.Format(“{0}, {1}, {2}”, Red, Green, Blue)
        End Function
        End Structure
      4. Test the struct.
        Public Class Tester
        Public Sub Run()
        ’Create an instance of the struct
        Dim colour1 As Colour = New Colour(100, 50, 250)
        ’Display the values
        Console.WriteLine(“Colour1 Initialized using the non-default
        constructor: “)
        Console.WriteLine(“colour1 colour: {0}”, colour1)
        ’Invoke the default constructor
        Dim colour2 As Colour = New Colour()
        Console.WriteLine(“Colour2 Initialized using the default
        constructor: “)
        Console.WriteLine(“colour2 colour: {0}”, colour2)
        ’Pass the struct object to a method
        ’Redisplay the values in the struct
        Console.WriteLine(“Colour1 after calling the method
        ’MyMethod’: “)
        Console.WriteLine(“colour1 colour: {0}”, colour1)
        End Sub
        ’Method takes a struct as a parameter
        Public Sub MyMethod(ByVal col As Colour)
        ’Modify the values through the properties
        col.Red = 200
        col.Green = 100
        col.Blue = 50
        Console.WriteLine(“colour values from inside the ‘MyMethod’
        method: {0}”, col)
        End Sub
        End ClassSub Main()
        Dim t As Tester = New Tester()
        End Sub
      5. Run your application:
      6. View code file.

Lab 7 – Interfaces
Create an Interface and a Class to hold client details. Instantiate an object from the class in code.

      1. Open Visual Studio and create a new VB Console Application. (Same as Lab 1 > first point). The Solution name and the project name is VBInterfaceDemo
      2. Define an interface called IClient.
        Interface IClient
        Sub Order(ByVal orderNum As Integer)
        Property Name() As String
        Property Address() As String
        End Interface
      3. Create a second class called Customer that implements all the interface’s members.
        ‘Create a Customer class that implements the IClient interface
        Public Class Customer Implements IClient
        ’Implement the properties
        Public Property Name As String Implements IClient.Name
        Public Property Address As String Implements IClient.Address
        Public Sub New(ByVal s As String)
        Console.WriteLine(“Creating a New Customer ID: {0}”, s)
        End Sub
        ’Implement the Order method
        Public Sub Order(ByVal newOrder As Integer) Implements IClient.Order
        Console.WriteLine(“Implementing the Order Method for IClient.
        The Order Number is: {0}”, newOrder)
        End Sub
        End Class
      4. Run your application:
      5. View code file

If you liked this post, please comment with your suggestions to help others.
If you would like to see more content like this in the future, please fill-in our quick survey.
Scroll to Top