'Re'implementing Interface Implementations: VB.NET vs. C#

Let's say we have an interface implemented on a class. We want to create a subclass derived from the super class and change the implementation . The difference between C# and VB.Net make this a little tricky. So let's take a look at how it's done.

The core difference between the way VB.NET and C# achieve what I'm calling 're'implementation is that in VB.NET you can not implement an interface on a subclass of a superclass that has already implemented it. In C# you can. Instead of implementing the interface a second time, you can override the superclass method that implements the interface method. This probably sounds like a word scramble so let's take a look at the example in code to clarify. We'll start the example using a VB.NET console application. Here's the code so you can take a first look:
Imports System

Namespace MyInterfaceTest

	Public Interface MyInterface
		Sub MyMethod()
	End Interface

	Public Class BaseClass : Implements MyInterface
		Public Overridable Sub MyMethod() Implements MyInterface.MyMethod
			Console.WriteLine("BaseClass.MyMethod")
		End Sub
	End Class

	Public Class DerivedClass : Inherits BaseClass
		Public Overrides Sub MyMethod()
			Console.WriteLine("DerivedClass.MyMethod")
		End Sub
	End Class

	Class EntryPoint
		Public Shared Sub Main()
			Dim iTest As MyInterface
			iTest = New BaseClass
			iTest.MyMethod()
			iTest = New DerivedClass
			iTest.MyMethod()
		End Sub
	End Class

End Namespace
Now let's take a look at the pieces of the code in more detail. First we have the start of the file and interface with the single method defined.
Imports System
	
Namespace MyInterfaceTest

	Public Interface MyInterface
		Sub MyMethod()
	End Interface
Then we have the super class that provides the first implementation of the interface method.
	Public Class BaseClass
		Implements MyInterface
		Public Overridable Sub MyMethod() Implements MyInterface.MyMethod
			Console.WriteLine("BaseClass.MyMethod")
		End Sub
	End Class
Next comes the sub class that overrides the super class method which implements the interface method. This essentially "reimplements" the interface's method.
	Public Class DerivedClass
		Inherits BaseClass
		Public Overrides Sub MyMethod()
			Console.WriteLine("DerivedClass.MyMethod")
		End Sub
	End Class
Finally we have the module with the Main sub to run the console app.
	Class EntryPoint
		Public Sub Main()
			Dim iTest As MyInterface
			iTest = New BaseClass
			iTest.MyMethod()
			iTest = New DerivedClass
			iTest.MyMethod()
		End Sub
	End Class

End Namespace
Here we create a variable of the MyInterface type. We set it to a new instance of BaseClass and call the interface method. Then we set it to a new instance of DerivedClass and call the interface method.

Here is the resulting output:

BaseClass.MyMethod
DerivedClass.MyMethod


As you can see, the interface calls correspond to the desired output.

Now let's take a look as the same code translated into C#.
using System;

namespace MyInterfaceTest{

	public interface MyInterface{
	    void MyMethod();
	}

	public class BaseClass : MyInterface{
		void MyInterface.MyMethod(){
			Console.WriteLine("BaseClass.MyMethod");
		}
	}

	public class DerivedClass : BaseClass, MyInterface{
		void MyInterface.MyMethod(){
			Console.WriteLine("DerivedClass.MyMethod");
		}
	}

	class EntryPoint{
		public static void Main(){
			MyInterface iTest;
			iTest = new BaseClass();
			iTest.MyMethod();
			iTest = new DerivedClass();
			iTest.MyMethod();
		}
	}

}
Assuming that you have a basic understanding of the syntax differences between VB.NET and C#, let's look at the more relevant differences between the two.

The first notable difference is the use of the Overridable keyword in VB.NET
	Public Class BaseClass : Implements MyInterface
		Public Overridable Sub MyMethod() Implements MyInterface.MyMethod
			Console.WriteLine("BaseClass.MyMethod")
		End Sub
	End Class
C# does not require anything special for that method.
	public class BaseClass : MyInterface{
		void MyInterface.MyMethod(){
			Console.WriteLine("BaseClass.MyMethod");
		}
	}
The code for the derived class is where the real obvious differences lay. First we see that in the VB.NET code our class only inherits from BaseClass. In C# the derived class also implements the interface.
	Public Class DerivedClass : Inherits BaseClass

	public class DerivedClass : BaseClass, MyInterface{
Next comes the method. In VB.NET the method overrides the base class' method. In C# the method is defined as the interface method. It also omits the Public keyword as this is implied by the implementation of the interface's method.
		Public Overrides Sub MyMethod()

		void MyInterface.MyMethod(){
As you can see, the differences between the VB.NET and C# versions are subtle but significant. In some cases these types of differences could lead you to believe that something you can do in one language cannot be done in another. However, short of a few exceptions the same tasks can be accomplished in both languages. That's part of the fun, excitement and, of course, inevitable frustration that comes with working in a multi-language environment.

Where to Next?

Wonder where to go next? You can read existing comments below or you can post a comment yourself on this article .


Consider making a donation
Please consider making a donation using PayPal. Your donation helps me to pay the bills so I can keep running Imar.Spaanjaars.Com, providing fresh content as often as possible.



Feedback by Other Visitors of Imar.Spaanjaars.Com

On Thursday, April 20, 2006 2:25:50 PM Sean said:
Hi,
I just don't understand why you have to tell that DerivedClass implements MyInterface if the (c# version) if your BaseClass already does that and Derived class doesn't provide it's own version MyMethod()? Is there's something I'm missing?
Thanks
On Wednesday, December 27, 2006 2:39:13 PM David Shannon said:
Thanks!  This helped me get a handle on re-implementation.  Very clear examples.
On Friday, October 24, 2008 8:31:11 PM Luis Falconi said:
Thanks,

I looking for this in more webs, you help my.

sorry my English
On Tuesday, December 13, 2011 11:51:59 PM Aaron said:
So what if you have no control over BaseClass so you cannot mark the method as Overridable.  In C# you can still override but in VB you cannot.  Is their a way around this?
On Wednesday, December 14, 2011 4:40:55 PM Imar Spaanjaars said:
Hi Aaron,

You can use Shadows in VB to hide a parent member and reimplement it in your child class. However, you should try to avoid using Shadows if possible.

Cheers,

Imar
On Monday, February 11, 2013 4:01:17 AM Mark Hurd said:
As mentioned above, and at my answer here:

http://stackoverflow.com/a/11288391/256431

you can use Shadows and even though there is a warning, the documentation states "if it is what you meant to do, ignore the warning"!

Talk Back! Comment on Imar.Spaanjaars.Com

I am interested in what you have to say about this article. Feel free to post any comments, remarks or questions you may have about this article. The Talk Back feature is not meant for technical questions that are not directly related to this article. So, a post like "Hey, can you tell me how I can upload files to a MySQL database in PHP?" is likely to be removed. Also spam and unrealistic job offers will be deleted immediately.

When you post a comment, you have to provide your name and the comment. Your e-mail address is optional and you only need to provide it if you want me to contact you. It will not be displayed along with your comment. I got sick and tired of the comment spam I was receiving, so I have protected this page with a simple calculation exercise. This means that if you want to leave a comment, you'll need to complete the calculation before you hit the Post Comment button.

If you want to object to a comment made by another visitor, be sure to contact me and I'll look into it ASAP. Don't forget to mention the page link, or the QuickDocId of the document.

For more information about the Talk Back feature, check out this news item.