If you haven't had exactly the right requirement in one of your programs, you might not even be aware that the MyClass keyword exists. Most people need to use the much more common Me and MyBase keywords every now and then, but MyClass covers a fairly specialized and unique requirement. This Quick Tip explains what it is.
According to Microsoft, these three keywords are "object variable like". In other words, in most cases, Me, MyBase, and MyClass act just like objects. You use them along with methods and properties in a syntax like this:
MyClass.<some method or property>
To get started, Me refers to "the specific instance of a class or structure in which the code is currently executing." Most programmers run into it because it's required when referring to the form in a Windows Forms based application:
Click Here to display the illustration
MyBase refers to "the base class of the current instance of a class." So when an instance of a class inherits another class, MyBase refers to the parent, like this:
Public Class baseClass Public theBaseClassObject As String = "Whatever" End Class Class derivedClass Inherits baseClass Public Sub ReferenceMyBaseObject() Console.WriteLine(MyBase.theBaseClassObject) End Sub End Class
This code uses the baseClass object as inherited in derivedClass:
Dim instantiateDerivedClass As New derivedClass instantiateDerivedClass.ReferenceMyBaseObject()
A more complete article that introduces these keywords and more can be found at:
It would seem that all contingencies have been covered, but there's one that hasn't yet. Suppose a derived class method or property overrides a property with the same name in a base class. Here's a method being overridden.
Public Class baseClass Public Overridable Sub theMethod() ' baseClass code goes here End Sub End Class Class derivedClass Inherits baseClass Public Overrides Sub theMethod() ' new derivedClass code goes here ' this code runs, not baseClass code MyBase.theMethod() End Sub End Class
Visual Studio AutoComplete adds the statement ...
... automatically because you will normally want to add some new processing and then continue with the processing that is already there in the base class. In general, you won't know what processing is in the base class. (It's often a code library that you don't have access to.) Overrides is explained in more detail in this article: Overrides in VB.NET.
Because the method is overridden in the derived class, the code there is executed rather than the base class code. (That's why MyBase.theMethod is usually a good idea.) But what if the base class author didn't want any code in a derived class to run for some reason. (For example, suppose it's a security application and derived classes can implement their own security by overriding, but there are some fundamental methods that must not be overridden.) How do you make sure that happens?
The answer is MyClass. As Microsoft's documentation states, "all method calls on it are treated as if the method were NotOverridable." Microsoft has a pretty good example of a method, but it also works with properties. Using an example developed in the article Overriding ToString, this code shows how MyClass can be used to ensure that a property isn't overridden. Here's the base class code:
Public Class baseClass Dim theDate As Long Public Overridable ReadOnly Property _ theProperty As Long Get Dim aYear As Integer = Now.Year Dim aMonth As Integer = Now.Month Dim aDay As Integer = Now.Day theDate = DateSerial( aYear, aMonth, aDay ).Ticks + 999 Return theDate End Get End Property Public Sub useMe() Console.WriteLine( "Property using Me: " & theProperty) End Sub Public Sub useMyClass() Console.WriteLine( "Property using MyClass: " & MyClass.theProperty) End Sub End Class
Here's the derived class code:
Class derivedClass Inherits baseClass Dim theDate As Long Public Overrides ReadOnly Property _ theProperty As Long Get Dim aYear As Integer = Now.Year Dim aMonth As Integer = Now.Month Dim aDay As Integer = Now.Day theDate = DateSerial( aYear, aMonth, aDay ).ToBinary Return theDate End Get End Property End Class
The value 999 is added in the base class just to make it easier to see the difference.
In the base class, the sub useMe just references theProperty. Me is implied in this case and if you use it anyway ...
Console.WriteLine( "Property using Me: " & Me.theProperty)
... you get exactly the same result; that is, theProperty in the derived class is referenced. But when the MyClass keyword is used, the property in the base class is displayed.
Click Here to display the illustration