Question

Visual Studio seems to stop type checking function parameters when one of the parameters is an interface.

Consider the following:

' An interface and the class that implements it:
Public Interface IA

End Interface

Public Class A
    Implements IA
End Class


' Another reference type for the demonstration:
Public Class MyReferenceType

End Class


' A function that uses IA as the type of one of its parameters:
Private Function SomeFunc(ByVal a As IA, ByVal r As MyReferenceType)
    Return Nothing
End Sub

And here is an example of the type checking problems:

Private Sub Example()
    Dim a As IA = New A
    Dim r As New MyReferenceType

    ' Some other random reference type, choose any 
    ' other reference type you like
    Dim list As New List(Of String)

    ' Each of these calls to SomeFunc compile without errors.
    SomeFunc(r, r)
    SomeFunc(r, a)
    SomeFunc(list, r)
    SomeFunc(list, a)

    ' Does not compile due to type mismatch
    'SomeFunc(list, list)
End Sub

As my comments suggest, this code compiles fine, with no errors in the editor either. If I execute the program though I get System.InvalidCastException, which isn’t a surprise at all. I guess this is a type checking bug in the compiler? I’m using Visual Studio 2005, so is this fixed in a later version of VS?

Answer 1

I believe it’s because you’ve got Option Strict off. If you turn Option Strict on to start with, your code fails to compile, exactly as we’d expect.

Note that this:

SomeFunc(list, a)

is not like this:

SomeFunc(list, list)

In the first case, when Option Strict is off, the compiler is effectively inserting a cast for you. After all, a value of type IA can be a MyReferenceType.

In the second case, a value of List(Of String) cannot ever be compatible with MyReferenceType (with the arguable exception of a value of Nothing…), so even with Option Strict off, compilation fails. The compiler won’t let you try something which can’t ever work.

Moral of the story: for better type checking, turn Option Strict on.