VB.NET class inherits a base class and implements an interface issue (works in C#)

Question

I am trying to create a class in VB.NET which inherits a base abstract class and also implements an interface. The interface declares a string property called Description. The base class contains a string property called Description. The main class inherits the base class and implements the interface. The existence of the Description property in the base class fulfills the interface requirements. This works fine in C# but causes issues in VB.NET.

First, here is an example of the C# code which works:

public interface IFoo
{
    string Description { get; set; }
}

public abstract class FooBase
{
    public string Description { get; set; }
}

public class MyFoo : FooBase, IFoo
{
}

Now here is the VB.NET version which gives a compiler error:

Public Interface IFoo
    Property Description() As String
End Interface

Public MustInherit Class FooBase
    Private _Description As String
    Public Property Description() As String
        Get
            Return _Description
        End Get
        Set(ByVal value As String)
            _Description = value
        End Set
    End Property
End Class

Public Class MyFoo
    Inherits FooBase
    Implements IFoo
End Class

If I make the base class (FooBase) implement the interface and add the Implements IFoo.Description to the property all is good, but I do not want the base class to implement the interface.

The compiler error is:

Class 'MyFoo' must implement 'Property Description() As String' for interface 'IFoo'. Implementing property must have matching 'ReadOnly' or 'WriteOnly' specifiers.

Can VB.NET not handle this, or do I need to change my syntax somewhere to get this to work?

Answer 1

One way or the other, you must specify the implementation details of the IFoo interface.

What about this simple option?

Public Class MyFoo
    Inherits FooBase
    Implements IFoo
    Overloads Property Description() As String Implements IFoo.Description
        Get
            Return MyBase.Description
        End Get
        Set(ByVal value As String)
            MyBase.Description = value
        End Set
    End Property
End Class

Answer 2

You need to mark your property as Overridable or MustOverride in the base class and then you can override it in the child class:

Public MustInherit Class FooBase
    Private _Description As String
    Public Overridable Property Description() As String
        Get
            Return _Description
        End Get
        Set(ByVal value As String)
            _Description = value
        End Set
    End Property
End Class

Public Class MyFoo
    Inherits FooBase
    Implements IFoo
    Public Overrides Property Description() As String Implements IFoo.Description
        Get
            Return MyBase.Description
        End Get
        Set(ByVal value As String)
            MyBase.Description = value
        End Set
    End Property
End Class

Edit This is in response to what @M.A. Hanin posted. Both of our solutions work but its important to understand the ramifications of each. Imagine the following code:

    Dim X As FooBase = New MyFoo()
    Trace.WriteLine(X.Description)

What comes out of the X.Description? Using the Overridable you'll get the call to the child class while using the Overload method you'll get the call to the base class. Neither is right or wrong, its just important to understand the consequences of the declaration. Using the Overload method you have to up-cast to get the child's implementation:

Trace.WriteLine(DirectCast(X, MyFoo).Description)

If you're just calling MyBase.Description from the child class the question is moot but if you ever change the definition of the child class then you just need to make sure you understand what's going on.

Answer 3

This is a strange issue and it clearly shows a difference between the C# and VB.NET compilers. I would suggest that you do implement the interface on the abstract base class as this will make the VB.NET compiler happy and at execution time your child class will still have metadata indicating that it does in fact implement IFoo.

Is there a specific reason that the child class must be the one to declare that it implements the interface?

Answer 4

VB requires that the implementing property declare the implementation. This is because of what I actually consider a nice feature of VB that I sometimes miss in C# -- that you can rename the member that implements the interface member.

Thus the only way to make this work without implementing IFoo.Description in FooBase is to declare Description Overridable and then define MyFoo as:

Public Class MyFoo
    Inherits FooBase
    Implements IFoo

    Public Overrides Property Description() As String Implements IFoo.Description
        Get
            Return MyBase.Description
        End Get
        Set(ByVal value As String)
            MyBase.Description = value
        End Set
    End Property
End Class