'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 post a comment on this article.    




  

        
    

  




  

    

      Doc ID
      337
    

    

      Full URL
      https://imar.spaanjaars.com/337/reimplementing-interface-implementations-vbnet-vs-c-sharp
    

    

      Short cut
      https://imar.spaanjaars.com/337/
    

    

      Written by
      Imar Spaanjaars
    

    

      Date Posted
      01/05/2005 18:09
    

      

        Date Last Reviewed
        05/24/2006 20:56
      

  





Comments



  
  








    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 Doc ID of the document.




    
    

        
        

            
            
            
        

        

            
            
            
        

        

            

                
                
                    (Plain text only; no HTML or code that looks like HTML or XML. In other words, don't use < and >. Also no links allowed.