VB.NET preserves the Implements keyword, and in fact the entire concept of interfaces is enhanced and made simpler as compared to VB6.

Working with Interfaces

VB.NET introduces a formalized structure for declaring interfaces. It also changes the syntax used in classes that implement an interface, making our code much more intuitive and clear.

Interface Declaration

The most visible enhancement is the introduction of a formal syntax for declaring an interface. This is done by using the Interface keyword:

Public Interface MyInterface
Event MyEvent()
Sub MyMethod()
Function MyFunction(ByVal Param1 As Integer) As Integer
Property MyProperty() As String
End Interface

This approach is much more formal that the approaches available in VB6. It is also more powerful - notice that not only can we declare Sub, Function, and Property methods, but also declare events as a formal part of an interface.

All the elements described in this interface must be implemented by any class that chooses to implement this interface.

Overloading Methods

Methods (Sub and Function) can be declared in an interface using the Overloads keyword. The rules for overloading are the same as we discussed earlier in the chapter - each overloaded declaration must have a unique parameter list based on data type of the parameters.

Declaring an interface with overloaded methods is done as in the following example:

Public Interface MyInterface
Overloads Sub MyMethod()
Overloads Sub MyMethod(Data As String)
Overloads Function MyFunction(ByVal Param1 As Integer) As Integer
Overloads Function MyFunction(ByVal Param1 As Single) As Integer
End Interface

When a class uses the Implements keyword to implement an interface with overloaded methods, the class must implement each of the overloaded method declarations.

Implementing an Interface

As with VB6, implementing an interface is done through the use of the Implements keyword:

Public Class TheClass
Implements MyInterface
End Class

From there, however, things get a bit different. In VB6 we'd implement the various interface elements as a set of specially named Private methods. That approach was unintuitive and was the cause for great confusion among many developers new to the language. VB.NET addresses this issue by providing a clear, concise syntax for implementing the interface - again through the application of the Implements keyword.

We can simply mark a method in our class as being the implementation of a specific method from the interface:

Public Sub MyMethod() Implements MyInterface.MyMethod

So, to implement our example interface, we'd have code such as:

Public Class TheClass
Implements MyInterface

Public Event MyEvent() Implements MyInterface.MyEvent

Public Function MyFunction(ByVal Param1 As Integer) _
  As System.Integer Implements OOlib.MyInterface.MyFunction
 
End Function

Public Sub MyMethod() Implements OOlib.MyInterface.MyMethod
 
End Sub

Public Property MyProperty() As String _
  Implements OOlib.MyInterface.MyProperty
 Get
  
 End Get
 Set
  
 End Set
End Property
End Class

As with VB6, when we implement an interface, we must implement all the elements in that interface - including events, methods, and properties.

We can now create client code that interacts with our object via this interface, in addition to the object's normal interface:

Dim obj As MyInterface

obj = New Implementer()
obj.MyMethod

Contrast this to VB6, where the routine to implement a method from an interface was written as follows:

Private Sub MyInterface_MyMethod()
' implementation goes here
End Sub

The fact that this method implements part of the interface is only shown by its naming - a pretty obscure thing. We could declare this as Public and make it available for external use, but the name of the method couldn't change. Now, with VB.NET the name (and scope) of the method is independent of the interface element being implemented.

Implementing Multiple Interfaces

A class can have more than one Implements statement - thus implementing more than one interface. Suppose we have the following interfaces:

Public Interface MyInterface
Sub DoSomething()
End Interface

Public Interface OtherInterface
Sub DoWork()
End Interface

We can construct a class that implements both interfaces:

Public Class TheClass
Implements MyInterface
Implements OtherInterface

End Class

Now we have a choice. We can either implement separate methods to handle DoSomething and DoWork:

Private Sub DoSomething() Implements MyInterface.DoSomething
 ' implementation goes here
End Sub

Private Overloads Sub DoWork() Implements OtherInterface.DoWork
 ' implementation goes here
End Sub

Or, if they do the same thing, we can have a single method implement both methods:

Private Sub DoSomething() _
  Implements MyInterface.DoSomething, OtherInterface.DoWork

 ' implementation goes here
End Sub

This is done by combining the list of implemented methods in a comma-separated list following the Implements keyword.