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:
   
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)
contr.DrawControl()
‘Create a derived instance
Dim txt As TextBox = New TextBox(20,
30, “Hello world”)
txt.DrawControl()
Console.ReadLine()
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,
lhs.denominator)
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
’Properties
Public Property Red As Integer
Public Property Green As Integer
Public Property Blue As Integer
’Constructor
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)
Console.WriteLine()
’Invoke the default constructor
Dim colour2 As Colour = New Colour()
Console.WriteLine(“Colour2 Initialized using the default
constructor: “)
Console.WriteLine(“colour2 colour: {0}”, colour2)
Console.WriteLine()
’Pass the struct object to a method
MyMethod(colour1)
’Redisplay the values in the struct
Console.WriteLine(“Colour1 after calling the method
’MyMethod’: “)
Console.WriteLine(“colour1 colour: {0}”, colour1)
Console.WriteLine()
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)
Console.WriteLine()
End Sub
End ClassSub Main()
Dim t As Tester = New Tester()
t.Run()
Console.ReadLine()
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