Object-oriented programming II in Visual Basic

In this chapter of the Visual Basic tutorial, we continue description of the OOP in the Visual Basic language.

Interfaces

A remote control is an interface between the viewer and the TV. It is an interface to this electronic device. Diplomatic protocol guides all activities in the diplomatic field. Rules of the road are rules that motorists, cyclists and pedestrians must follow. Interfaces in programming are analogous to the previous examples.

Interfaces are:

Objects interact with the outside world with the methods, they expose. The actual implementation is not important to the programmer, or it also might be secret. A company might sell a library and it does not want to disclose the actual implementation. A programmer might call a Maximize method on a window of a GUI toolkit, but knows nothing about how this method is implemented. From this point of view, interfaces are methods, through which objects interact with the outside world, without exposing too much about their inner workings.

From the second point of view, interfaces are contracts. If agreed upon, they must be followed. They are used to design an architecture of an application. They help organise the code.

Interfaces are fully abstract types. They are declared using the Interface keyword. Interfaces can only have method signatures and constants. All method signatures declared in an interface must be public. They cannot have fully implemented methods, nor member fields. A Visual Basic class may implement any number of interfaces. An interface can also extend any number of interfaces. A class that implements an interface must implement all method signatures of an interface.

Interfaces are used to simulate multiple inheritance. A Visual Basic class can inherit only from one class. A Visual Basic class can implement multiple interfaces. Multiple inheritance using the interfaces is not about inheriting methods and variables. It is about inheriting ideas or contracts, which are described by the interfaces.

There is one important distinction between interfaces and abstract classes. Abstract classes provide partial implementation for classes that are related in the inheritance hierarchy. Interfaces on the other hand can be implemented by classes that are not related to each other. For example, we have two buttons. A classic button and a round button. Both inherit from an abstract button class that provides some common functionality to all buttons. Implementing classes are related, since all are buttons. Another example might have classes Database and SignIn. They are not related to each other. We can apply an ILoggable interface that would force them to create a method to do logging.

Option Strict On


Module Example

    Interface IInfo

       Sub DoInform()
    
    End Interface

    Class Some
        Implements IInfo

        Sub DoInform() Implements IInfo.DoInform
            Console.WriteLine("This is Some Class")
        End Sub
    
    End Class

    Sub Main()
        
        Dim sm As New Some
        sm.DoInform()    

    End Sub
    
End Module

This is a simple Visual Basic program demonstrating an interface.

Interface IInfo
    Sub DoInform()
End Interface

This is an interface IInfo. It has the DoInform() method signature.

Class Some
    Implements IInfo

We use the Implements to implement from an interface.

Sub DoInform() Implements IInfo.DoInform
    Console.WriteLine("This is Some Class")
End Sub

The class provides an implementation for the DoInform() method. The Implements keyword explicitly specifies which method signature we are implementing.

The next example shows, how a class can implement multiple interfaces.

Option Strict On


Module Example

    Interface Device

       Sub SwitchOn()
       Sub SwitchOff()
    
    End Interface

    Interface Volume

       Sub VolumeUp()
       Sub VolumeDown()
    
    End Interface

    Interface Pluggable

       Sub PlugIn()
       Sub PlugOff()
    
    End Interface

    Class CellPhone
        Implements Device, Volume, Pluggable

        Public Sub SwitchOn() Implements Device.SwitchOn
            Console.WriteLine("Switching on")
        End Sub

        Public Sub SwitchOff() Implements Device.SwitchOff
            Console.WriteLine("Switching on")
        End Sub

        Public Sub VolumeUp() Implements Volume.VolumeUp
            Console.WriteLine("Volume up")
        End Sub

        Public Sub VolumeDown() Implements Volume.VolumeDown
            Console.WriteLine("Volume down")
        End Sub

        Public Sub PlugIn() Implements Pluggable.PlugIn
            Console.WriteLine("Plugging In")
        End Sub

        Public Sub PlugOff() Implements Pluggable.PlugOff
            Console.WriteLine("Plugging Off")
        End Sub
    
    End Class

    Sub Main()
        
        Dim o As New CellPhone
        o.SwitchOn()
        o.VolumeUp()
        o.PlugIn()

    End Sub
    
End Module

We have a CellPhone class that inherits from three interfaces.

Class CellPhone
    Implements Device, Volume, Pluggable

The class implements all three interfaces, which are divided by a comma. The CellPhone class must implement all method signatures from all three interfaces.

$ ./interface.exe 
Switching on
Volume up
Plugging In

Running the program.

The next example shows how interfaces can inherit from multiple other interfaces.

Option Strict On


Module Example

    Interface IInfo

        Sub DoInform()
    
    End Interface

    Interface IVersion

       Sub GetVersion()
    
    End Interface

    Interface ILog
        Inherits IInfo, IVersion

       Sub DoLog
    
    End Interface

    Class DBConnect
        Implements ILog

        Public Sub DoInform() Implements IInfo.DoInform
            Console.WriteLine("This is DBConnect class")
        End Sub

        Public Sub GetVersion() Implements IVersion.GetVersion
            Console.WriteLine("Version 1.02")
        End Sub

        Public Sub DoLog() Implements ILog.DoLog
            Console.WriteLine("Logging")
        End Sub

        Public Sub Connect()
            Console.WriteLine("Connecting to the database")
        End Sub
    
    End Class

    Sub Main()
        
        Dim db As New DBConnect
        db.DoInform()
        db.GetVersion()
        db.DoLog()
        db.Connect()

    End Sub
    
End Module

We define three interfaces. We can organise interfaces in hierarchy.

Interface ILog
    Inherits IInfo, IVersion

The ILog interface inherits from two other interfaces.

Public Sub DoInform() Implements IInfo.DoInform
    Console.WriteLine("This is DBConnect class")
End Sub

The DBConnect class implements the DoInform() method. This method was inherited by the ILog interface, which the class implements.

$ ./interface2.exe 
This is DBConnect class
Version 1.02
Logging
Connecting to the database

Output.

Polymorphism

The polymorphism is the process of using an operator or function in different ways for different data input. In practical terms, polymorphism means that if class B inherits from class A, it doesn't have to inherit everything about class A; it can do some of the things that class A does differently. (wikipedia)

In general, polymorphism is the ability to appear in different forms. Technically, it is the ability to redefine methods for derived classes. Polymorphism is concerned with the application of specific implementations to an interface or a more generic base class.

Polymorphism is the ability to redefine methods for derived classes.

Option Strict On


Module Example

    MustInherit Class Shape

        Protected x As Integer
        Protected y As Integer
    
        Public MustOverride Function Area() As Integer

    End Class

    Class Rectangle 
        Inherits Shape
    
        Sub New(ByVal x As Integer, ByVal y As Integer)
            Me.x = x
            Me.y = y
        End Sub

        Public Overrides Function Area() As Integer
            Return Me.x * Me.y
        End Function
 
    End Class


    Class Square 
        Inherits Shape
    
        Sub New(ByVal x As Integer)
            Me.x = x
        End Sub

        Public Overrides Function Area() As Integer
            Return Me.x * Me.x
        End Function

    End Class

    Sub Main()
        
        Dim shapes() As Shape = { New Square(5), _
            New Rectangle(9, 4), New Square(12) } 

        For Each shape As Shape In shapes
            Console.WriteLine(shape.Area())
        Next

    End Sub
    
End Module

In the above program, we have an abstract Shape class. This class morphs into two descendant classes, Rectangle and Square. Both provide their own implementation of the Area() method. Polymorphism brings flexibility and scalability to the OOP systems.

Public Overrides Function Area() As Integer
    Return Me.x * Me.y
End Function
...
Public Overrides Function Area() As Integer
    Return Me.x * Me.x
End Function

Rectangle and Square classes have their own implementations of the Area method.

Dim shapes() As Shape = { New Square(5), _
    New Rectangle(9, 4), New Square(12) } 

We create an array of three Shapes.

For Each shape As Shape In shapes
    Console.WriteLine(shape.Area())
Next

We go through each shape and call Area method on it. The compiler calls the correct method for each shape. This is the essence of polymorphism.

NotOverridable, NotInheritable

NotOverridable methods cannot be overridden and NotInheritable classes cannot be inherited from. These keywords are a matter of a design of the application. We should not inherit from some classes and some methods should not be overridden.

Option Strict On


Module Example

    Class Base

        Public NotOverridable Sub Say()
            Console.WriteLine("Base class")
        End Sub

    End Class

    Class Derived
        Inherits Base

        Public Overrides Sub Say()
            Console.WriteLine("Derived class")
        End Sub

    End Class

    Sub Main()

        Dim o As Base = New Derived
        o.Say()

    End Sub

End Module

This program won't compile. We get an error 'Public Overrides Sub Say()' cannot override 'Public NotOverridable Sub Say()' because it is declared 'NotOverridable'.

Option Strict On


Module Example

    NotInheritable Class Math

        Public Shared Function getPI() As Single
            Return 3.141592
        End Function

    End Class

    Class DerivedMath
        Inherits Math

        Public Sub Say()
            Console.WriteLine("DerivedMath class")
        End Sub

    End Class

    Sub Main()

        Dim o As DerivedMath = New DerivedMath
        o.Say()

    End Sub

End Module

In the above program, we have a prototype base Math class. The sole purpose of this class is to provide some helpful methods and constants to the programmer. (In our case we have only one method for simplicity reasons.) It is not created to be inherited from. To prevent uninformed other programmers to derive from this class, the creators made the class NotInheritable. If you try to compile this program, you get the following error: 'DerivedMath' cannot inherit from class 'Math' because 'Math' is declared 'NotInheritable'.

Deep copy vs shallow copy

Copying of data is an important task in programming. Object is a composite data type in OOP. Member field in an object may be stored by value or by reference. Copying may be performed in two ways.

The shallow copy copies all values and references into a new instance. The data to which a reference is pointing is not copied; only the pointer is copied. The new references are pointing to the original objects. Any changes to the reference members affect both objects.

The deep copy copies all values into a new instance. In case of members that are stored as references a deep copy performs a deep copy of data that is being referenced. A new copy of a referenced object is created. And the pointer to the newly created object is stored. Any changes to those referenced objects will not affect other copies of the object. Deep copies are fully replicated objects.

If a member field is a value type, a bit-by-bit copy of the field is performed. If the field is a reference type, the reference is copied but the referred object is not; therefore, the reference in the original object and the reference in the clone point to the same object. (a clear explanation from programmingcorner.blogspot.com)

The next two examples will perform a shallow and a deep copy on objects.

Option Strict On


Module Example

    Class Color

        Public red as Byte
        Public green as Byte
        Public blue as Byte
 
        Sub New(red As Byte, green As Byte, _
            blue As Byte)
            Me.red = red
            Me.green = green
            Me.blue = blue
        End Sub

    End Class

    Class MyObject
        Implements ICloneable

        Public Id As Integer
        Public Size As String
        Public Col As Color

        Sub New(Id As Integer, Size As String, _
            Col As Color)
            Me.Id = Id
            Me.Size = Size
            Me.Col = Col
        End Sub

        Public Function Clone() As Object _
                          Implements ICloneable.Clone
          Return New MyObject(Me.Id, Me.Size, Me.Col)
        End Function

        Public Overrides Function ToString() As String
            Dim s As String
            s = String.Format("Id: {0}, Size: {1}, Color:({2}, {3}, {4})", _
                Me.Id, Me.Size, Me.Col.red, Me.Col.green, Me.Col.blue)
            Return s
        End Function

    End Class

    Sub Main()
        
        Dim col As New Color(23, 42, 223)    
        
        Dim obj1 As New MyObject(23, "small", col)
        Dim obj2 As MyObject

        obj2 = CType(obj1.Clone(), MyObject)
        
        obj2.Id += 1
        obj2.Size = "big"         
        obj2.Col.red = 255
         
        Console.WriteLine(obj1) 
        Console.WriteLine(obj2)

    End Sub
    
End Module

This is an example of a shallow copy. We define two custom objects: MyObject and Color. The MyObject object will have a reference to the Color object.

Class MyObject
    Implements ICloneable

We should implement ICloneable interface for objects, which we are going to clone.

Public Function Clone() As Object _
                  Implements ICloneable.Clone
    Return New MyObject(Me.Id, Me.Size, Me.Col)
End Function

The ICloneable interface forces us to create a Clone() method. This method returns a new object with copied values.

Dim col As New Color(23, 42, 223)  

We create an instance of the Color object.

Dim obj1 As New MyObject(23, "small", col)

An instance of the MyObject object is created. It passes the instance of the Color object to its constructor.

obj2 = CType(obj1.Clone(), MyObject)

We create a shallow copy of the obj1 object and assign it to the obj2 variable. The Clone() method returns an Object and we expect MyObject. This is why we do explicit casting.

obj2.Id += 1
obj2.Size = "big"         
obj2.Col.red = 255

Here we modify the member fields of the copied object. We increment the Id, change the Size to "big" and change the red part of the color object.

Console.WriteLine(obj1) 
Console.WriteLine(obj2)

The Console.WriteLine() method calls the ToString() method of the obj2 object, which returns the string representation of the object.

Id: 23, Size: small, Color:(255, 42, 223)
Id: 24, Size: big, Color:(255, 42, 223)

We can see that the Ids are different, 23 vs 24. The Size is different. "small" vs "big". But the red part of the color object is same for both instances: 255. Changing member values of the cloned object (Id, Size) did not affect the original object. Changing members of the referenced object (Col) has affected the original object too. In other words, both objects refer to the same color object in memory.

To change this behaviour, we will do a deep copy next.

Option Strict On


Module Example

    Class Color
        Implements ICloneable

        Public Red as Byte
        Public Green as Byte
        Public Blue as Byte
 
        Sub New(Red As Byte, Green As Byte, _
            Blue As Byte)
            Me.Red = Red
            Me.Green = Green
            Me.Blue = Blue
        End Sub

        Public Function Clone() As Object _
                          Implements ICloneable.Clone
          Return New Color(Me.Red, Me.Green, Me.Blue)
        End Function

    End Class

    Class MyObject
        Implements ICloneable

        Public Id As Integer
        Public Size As String
        Public Col As Color

        Sub New(Id As Integer, Size As String, _
            Col As Color)
            Me.Id = Id
            Me.Size = Size
            Me.Col = Col
        End Sub

        Public Function Clone() As Object _
                          Implements ICloneable.Clone
            Return New MyObject(Me.Id, Me.Size, CType(Me.Col.Clone(), Color))
        End Function

        Public Overrides Function ToString() As String
            Dim s As String
            s = String.Format("Id: {0}, Size: {1}, Color:({2}, {3}, {4})", _
                Me.Id, Me.Size, Me.Col.Red, Me.Col.Green, Me.Col.Blue)
            Return s
        End Function

    End Class

    Sub Main()
        
        Dim col As New Color(23, 42, 223)    
        
        Dim obj1 As New MyObject(23, "small", col)
        Dim obj2 As MyObject

        obj2 = CType(obj1.Clone(), MyObject)
        
        obj2.Id += 1
        obj2.Size = "big"         
        obj2.Col.Red = 255
         
        Console.WriteLine(obj1) 
        Console.WriteLine(obj2)


    End Sub
    
End Module

In this program, we perform a deep copy on object.

Class Color
    Implements ICloneable

Now the Color class implements the ICloneable interface.

Public Function Clone() As Object _
                  Implements ICloneable.Clone
    Return New Color(Me.Red, Me.Green, Me.Blue)
End Function

We have a Clone() method for the Color class too. This helps to create a copy of a referenced object.

Public Function Clone() As Object _
                  Implements ICloneable.Clone
    Return New MyObject(Me.Id, Me.Size, CType(Me.Col.Clone(), Color))
End Function

Now, when we clone the MyObject, we call the Clone() method upon the Col reference type. This way we have a copy of a color value too.

$ ./deepcopy.exe 
Id: 23, Size: small, Color:(23, 42, 223)
Id: 24, Size: big, Color:(255, 42, 223)

Now the red part of the referenced Color object is not the same. The original object has retained its previous 23 value.

Exceptions

Exceptions are designed to handle the occurrence of exceptions, special conditions that change the normal flow of program execution. Exceptions are raised or thrown, initiated.

During the execution of our application, many things might go wrong. A disk might get full and we cannot save our file. An Internet connection might go down and our application tries to connect to a site. All these might result in a crash of our application. To prevent happening this, we must cope with all possible errors that might occur. For this, we can use the exception handling.

The Try, Catch and Finally keywords are used to work with exceptions.

Option Strict On

Module Example

    Sub Main()
    
        Dim x As Integer = 100
        Dim y As Integer = 0    
        Dim z As Double
        
        Try 
            z = x \ y
        Catch e As Exception
            Console.WriteLine(e.Message)
        End Try

    End Sub

End Module

In the above program, we intentionally divide a number by zero. This leads to an error.

Try 
    z = x \ y
...
End Try

Statements that are error prone are placed after the Try keyword.

Catch e As Exception
    Console.WriteLine(e.Message)
...

Exception types follow the Catch keyword. In our case we have a generic Exception which will catch an exception of any type. There are some generic exceptions and some more specific. Statements that follow the Catch keyword are executed, when an error occurs. When an exception occurs, an exception object is created. From this object we get the Message property and print it to the console.

Any uncaught exception in the current context propagates to a higher context and looks for an appropriate catch block to handle it. If it can't find any suitable catch blocks, the default mechanism of the .NET runtime will terminate the execution of the entire program.

Option Strict On

Module Example

    Sub Main()
 
        Dim z As Double
        Dim x As Integer = 100
        Dim y As Integer = 0
        
        z = x \ y

    End Sub

End Module

In this program, we divide by zero. We have no custom exception handling. On Visual Basic 2008 Express we receive the following error message: 'Unhandled Exception: System.DivideByZeroException: Attempted to divide by zero.'.

Option Strict On

Imports System.IO

Module Example

    Dim fs As FileStream

    Sub Main()

        Try
            fs = File.Open("file", FileMode.OpenOrCreate)
            Console.WriteLine(fs.Length)
        Catch e As IOException
            Console.WriteLine("IO Error")
            Console.WriteLine(e.Message)
        Finally
            Console.WriteLine("Finally")
            If fs.CanRead = True Then
                fs.Close()
            End If
        End Try

    End Sub

End Module

The statements following the Finally keyword are always executed. It is often used to clean-up tasks, such as closing files or clearing buffers.

Catch e As IOException
    Console.WriteLine("IO Error")
    Console.WriteLine(e.Message)

In this case, we catch for a specific IOException exception.

Finally
    Console.WriteLine("Finally")
    If fs.CanRead = True Then
        fs.Close()
    End If

These lines guarantee that the file handler is closed.

Option Strict On

Module Example

    Sub Main()

        Dim x As Integer
        Dim y As Integer
        Dim z As Double

        Try
            Console.Write("Enter first number: ")
            x = Convert.ToInt32(Console.ReadLine())

            Console.Write("Enter second number: ")
            y = Convert.ToInt32(Console.ReadLine())

            z = x / y
            Console.WriteLine("Result: {0:D} / {1:D} = {2:D}", x, y, z)

        Catch e As DivideByZeroException
            Console.WriteLine("Cannot divide by zero.")
        Catch e As FormatException
            Console.WriteLine("Wrong format of number.")
        Catch e As Exception
            Console.WriteLine(e.Message)
        End Try

    End Sub

End Module

In this example, we catch for various exceptions. Note that more specific exceptions should precede the generic ones. We read two numbers from the console and check for zero division error and for wrong format of number.

$ ./passing.exe 
Enter first number: et
Wrong format of number.

Running the example.

Option Strict On

Module Example

    Class BigValueException
        Inherits Exception
    
        Sub New(ByVal msg As String)
            MyBase.New(msg)
        End Sub

    End Class

    Sub Main()
    
        Dim x As Integer = 340004
        Const LIMIT As Integer = 333    
        
        Try 
            If (x > LIMIT) Then
                Throw New BigValueException("Exceeded the maximum value")
            End If
        Catch e As BigValueException
            Console.WriteLine(e.Message)
        End Try

    End Sub

End Module

Let's say, we have a situation in which we cannot deal with big numbers.

Class BigValueException
    Inherits Exception

We have a BigValueException class. This class derives from the built-in Exception class.

Dim Const LIMIT As Integer = 333 

Numbers bigger than this constant are considered to be "big" by our program.

Sub New(ByVal msg As String)
    MyBase.New(msg)
End Sub

Inside the constructor, we call the parent's constructor. We pass the message to the parent.

If (x > LIMIT) Then
    Throw New BigValueException("Exceeded the maximum value")
End If

If the value is bigger than the limit, we throw our custom exception. We give the exception a message "Exceeded the maximum value".

Catch e As BigValueException
    Console.WriteLine(e.Message)

We catch the exception and print its message to the console.

Properties

Properties are special kind of class members. We use predefined set and get methods to access and modify them. Property reads and writes are translated to get and set method calls. Accessing variables with a field notation (e.g. object.Name) is easier than with custom method calls.(e.g. object.GetName()). However with properties, we still have the advantage of encapsulation and information hiding.

Option Strict On


Module Example

    Class Person

        Private _name As String

        Public Property Name() As String
            Get
                Return _name
            End Get
         
            Set (Byval Value As String)
                _name = Value
            End Set
        End Property
          
    End Class

    Sub Main()
        
        Dim p as New Person
        p.Name = "Jane"

        Console.WriteLine(p.Name())
  
    End Sub
    
End Module

We have a simple Person class with one property.

Public Property Name() As String
...
End Property

We use the Property keyword to create properties in Visual Basic.

Get
    Return _name
End Get

We use the predefined Get keyword to create an accessor method to the _name field.

Set (Byval Value As String)
    _name = Value
End Set

Similarly, the Set keyword creates a mutator method for the _name field.

Dim p as New Person
p.Name = "Jane"

Console.WriteLine(p.Name())

We create an instance of the Person class. We access the member field using the field notation.

$ ./properties.exe 
Jane

This is the outcome of the program.

Delegates

A delegate is a form of type-safe function pointer used by the .NET Framework. Delegates are often used to implement callbacks and event listeners.

Option Strict On


Module Example

    Public Delegate Sub NameDelegate(ByVal msg As String)

    Class Person

        Private FirstName As String
        Private SecondName As String

        Sub New(First As String, Second As String)
            Me.FirstName = First
            Me.SecondName = Second
        End Sub

        Public Sub ShowFirstName(msg As String)
            Console.WriteLine(msg & Me.FirstName)
        End Sub

        Public Sub ShowSecondName(msg As String)
            Console.WriteLine(msg & Me.SecondName)
        End Sub
    
    End Class

    Sub Main()
        
        Dim nDelegate As NameDelegate

        Dim per As New Person("Fabius", "Maximus")       

        nDelegate = AddressOf per.ShowFirstName
        nDelegate("Call 1: ")

        nDelegate = AddressOf per.ShowSecondName
        nDelegate("Call 2: ")                    

    End Sub
    
End Module

In the example we have one delegate. This delegate is used to point to two methods of the Person class. The methods are called with the delegate.

Public Delegate Sub NameDelegate(ByVal msg As String)

The delegate is created with a Delegate keyword. The delegate signature must match the signature of the method being called with the delegate.

Dim nDelegate As NameDelegate

Here we create a variable of our custom delegate type.

nDelegate = AddressOf per.ShowFirstName
nDelegate("Call 1: ")

The AddressOf operator is used to get the reference to the ShowFirstName( method. Now that we point to the method, we can call it via the delegate.

$ ./simpledelegate.exe 
Call 1: Fabius
Call 2: Maximus

Both names are printed via the delegate.

Events

Events are messages triggered by some action. Click on the button or tick of a clock are such actions. The object that triggers an event is called a sender and the object that receives the event is called a receiver.

Option Strict On


Module Example

    Public Event ValueFive() 

    Dim Random As Integer

    Public Sub Main()

        AddHandler ValueFive, AddressOf OnFiveEvent

        For i As Integer = 0 To 10

            Randomize()
            Random = CInt(Rnd() * 7)

            Console.WriteLine(Random)

            If Random = 5 Then
                RaiseEvent ValueFive() 
            End If
        Next

    End Sub

    Public Sub OnFiveEvent() 
        Console.WriteLine("Five Event occured")
    End Sub

End Module

We have a simple example in which we create and launch an event. An random number is generated. If the number equals to 5 a FiveEvent event is generated.

Public Event ValueFive() 

An event is declared with a Event keyword.

AddHandler ValueFive, AddressOf OnFiveEvent

Here we plug the event called ValueFive() to the OnFiveEvent() subroutine. In other words if the ValueFive event is triggered, the OnFiveEvent() subroutine is executed.

If Random = 5 Then
    RaiseEvent ValueFive() 
End If

When the random number equals to 5, we raise the ValueFive event. We use the RaiseEvent keyword.

$ ./event.exe 
0
1
5
Five Event occured
2
5
Five Event occured
6
7
6
3
3
1

Outcome of the program might look like this.

Next we have a more complex example.

Option Strict On


Namespace EventSample

    Public Class FiveEventArgs
        Inherits EventArgs

        Public Count As Integer
        Public Time As Date

        Public Sub New(ByVal Count As Integer, ByVal Time As Date)
            Me.Count = Count
            Me.Time = Time
        End Sub

    End Class

    Public Class Five

        Private Count As Integer = 0

        Public Sub OnFiveEvent(ByVal source As Object, _
                               ByVal e As FiveEventArgs)
            Console.WriteLine("Five event {0} occured at {1}", _
                              e.Count, e.Time)
        End Sub

    End Class

    Public Class RandomGenerator

        Public Event ValueFive(ByVal source As Object, _
                               ByVal e As FiveEventArgs)

        Public Sub Generate()

            Dim Count As Integer = 0
            Dim args As FiveEventArgs

            For i As Byte = 0 To 10
                Dim Random As Integer

                Randomize()
                Random = CInt(Rnd * 6)
                Console.WriteLine(Random)

                If Random = 5 Then
                    Count += 1
                    args = New FiveEventArgs(Count, Now)
                    RaiseEvent ValueFive(Me, args)
                End If
            Next
        End Sub

    End Class

    Public Class Example

        Public Shared Sub Main()

            Dim five As New Five
            Dim gen As New RandomGenerator

            AddHandler gen.ValueFive, AddressOf five.OnFiveEvent

            gen.Generate()

        End Sub

    End Class

End Namespace

We have four classes. FiveEventArgs carries some data with the event object. The Five class encapsulates the event object. RandomGenerator class is responsible for random number generation. It is the event sender. Finally the Example class, which is the main application object and has the Main() method.

Public Class FiveEventArgs
    Inherits EventArgs

    Public Count As Integer
    Public Time As Date
...

The FiveEventArgs carries data inside the event object. It inherits from the EventArgs base class. The Count and Time members are data that will be initialized and carried with the event.

If Random = 5 Then
    Count += 1
    args = New FiveEventArgs(Count, Now)
    RaiseEvent ValueFive(Me, args)
End If

If the generated random number equals to 5, we instantiate the FiveEventArgs class with the current Count and Date values. The Count variable counts the number of times this event was generated. The Time value holds the time, when the event was generated. The event is sent with the RaiseEvent keyword with the sender object and event arguments.

AddHandler gen.ValueFive, AddressOf five.OnFiveEvent

We plug the ValueFive event to its handler.

$ ./event2.exe 
3
6
5
Five event 1 occured at 9/15/2010 5:06:13 PM
3
5
Five event 2 occured at 9/15/2010 5:06:13 PM
6
3
2
5
Five event 3 occured at 9/15/2010 5:06:13 PM
2
5
Five event 4 occured at 9/15/2010 5:06:13 PM

This is the ouput I got on my computer.

In this part of the Visual Basic tutorial, we continued the discussion of the object-oriented programming in Visual Basic.