Inheritance from a Base Class in Microsoft .NET


Paul D. Sheriff
PDSA, Inc.

December 2001

Summary: This article explains inheritance, shows how to inherit from a base class, and describes implementation and interface inheritance in Microsoft .NET. (12 printed pages)


  • Overview of inheritance
  • Learn how to inherit from a base class
  • Learn about interface inheritance
  • Learn about implementation inheritance


The following should be true for you to get the most out of this document:

  • You understand basic coding
  • You understand classes and how they work and/or have read the Creating Classes in .NET article
  • You have access to Microsoft® Visual Basic® .NET


Overview of Inheritance
Inherit From a Base Class
Build the Sample Form
Create the Subclass
Add Additional Functionality
MyBase Keyword
Abstract Classes
Choosing the Type of Inheritance to Use
What's New Since Visual Basic 6.0?

Overview of Inheritance

One of the key features of Object Oriented Programming (OOP) languages is inheritance. Inheritance is the ability to use all of the functionality of an existing class, and extend those capabilities without re-writing the original class. Prior to the availability of Microsoft® Visual Basic® .NET, Visual Basic programmers did not have this capability. In Visual Basic .NET, you are able to inherit from classes that ship in the Microsoft .NET Framework, as well as from classes that you create. In this document, you will learn how to use inheritance, and see how it can significantly cut down your programming time.

A Simple Example

In many classes that you create, you will find that you often need the same properties and methods from another class that you created earlier. For example, if you have a base class called the Person class, and it contains LastName and FirstName properties and a Print method, you will find that for an Employee class, you need the same properties and methods. You may also need additional properties, such as EmployeeID and Salary. When you inherit from the Person class (the base class) you can add these properties to this new Employee class, and still have access to all of the properties in the Person class. Inheritance is about the ability for one class to define itself as having all the properties and methods of a particular class, and then extending the definition of the base class by adding additional properties and methods.

Inheritance Terminology

Before we delve too deeply into this topic, let's define a few terms. A new class that is created by inheritance is sometimes called a child class or a subclass. The class you originally inherited from is called the base class, parent class, or the superclass. In some OOP languages, a base class may inherit from more than one base class. This means that if you had a Person class and a Car class, a Driver class might inherit all of the properties and methods from each of these two classes. In the .NET world, only single inheritance is allowed, so each subclass will have only one base class.

There are three types of inheritance that .NET supports: implementation, interface, and visual. Implementation inheritance refers to the ability to use a base class's properties and methods with no additional coding. Interface inheritance refers to the ability to use just the names of the properties and methods, but the child class must provide the implementation. Visual inheritance refers to the ability for a child form (class) to use the base forms (class) visual representation as well as the implemented code.

A class in .NET may inherit from a class that has already inherited from another class. In addition you may use an interface or even multiple interfaces within a class.

Reasons for Using Inheritance

Inheritance is desirable because you want to avoid writing the same code over and over again. If you have two separate classes, and each one has to implement a FirstName and LastName property, you are going to have duplicate code. If you wish to change the implementation of one of these properties, you need to find all classes that have implemented these properties to make the changes. Not only is this time-consuming, but you also increase the risk of introducing bugs in the various classes.

One thing to remember when you are considering using inheritance is that the relationship between the two classes should be an "is a" type of relationship. For example, an Employee is a Person, and a Manager is a Person, so these two classes can inherit from the Person class. But you should not have a Leg class inherit from a Person class as a Leg is not a person.


Once you start inheriting functionality from a base class, you might find that the generic method you wrote in the base class only performs part of what you need in the inheriting class. Instead of creating a whole new method, with a new name, to perform the full functionality that you want, you can override the base class' method in this new class.

When you override, you have the option of completely overriding the base class' method, or you can write some code to do something in the inheriting class and then call the base class' method. It is important that you when you override you still use the same contract, (the parameters and return type), of the original method. You may also choose to call the base class' method first, and then write additional code after the base class' method has finished executing.

Inherit From a Base Class

Inheritance gives you the ability to use all of the properties and methods from one class within another class. Instead of having to copy and paste code from one class to another, you use the keyword Inherits to get the functionality from the base class.

Implementation Inheritance

In this document, you will create a new class called LineDelim that will inherit all of the functionality from the Line class created in the Creating Classes in .NET article. You will extend the Line class by adding two additional properties and one method. The first property, Delimiter, will allow you to get and set a delimiter character into the class. This delimiter will be used to replace all of the spaces in the line to this delimiter character. The second property, OriginalLine, will be used to hold the original line of text, prior to inserting the new delimiter into the line of text. The new method you will create, ReplaceAll(), will replace all the spaces in the line with the delimiter character. You will then learn to override the GetWord method so it uses this delimiter instead of spaces to break up the line of text and search for the first word.

Build the Sample Form

The sample form shown in Figure 1 will be used to test the inherited class that you will create.

Figure 1. Sample form to test inheritance

  1. To create the form shown in Figure 1, click Project, and then click Add Windows Form.
  2. Name the form frmLineTest.vb and click OK.
  3. Next create the appropriate controls on the form and set the properties as shown in Table 1.

    Table 1: Form to test inheritance

    Control Property Value
    Label Name Label1
      Text Line of Text
    TextBox Name txtLine
      Text The rain in Spain stays mainly in the plain
    TextBox Name txtDelim
      Text ,
    GroupBox Name fraWord
      Text Get First Word
    CommandButton Name btnFirst
      Text Get Word
    TextBox Name txtFirstWord
      ReadOnly True
    CommandButton Name btnReplace
      Text Replace
    TextBox Name txtReplace
      ReadOnly True

Build the Line Class

Next you build the Line class to inherit from.

  1. From the menu, click Project, and then click Add Class.
  2. Type in the code shown below.
    Public Class Line
        Private mstrLine As String
        Property Line() As String
                Return mstrLine
            End Get
            Set(ByVal Value As String)
                mstrLine = Value
            End Set
        End Property
        ReadOnly Property Length() As Integer
                Return mstrLine.Length
            End Get
        End Property
        Public Function GetWord() As String
            Dim astrWords() As String
            astrWords = mstrLine.Split(" ".ToCharArray())
            Return astrWords(0)
        End Function
    End Class

Create the Subclass

Now that you have the form and the base class created, it is time to start the inheritance process.

  1. Click Project, and then click Add Class. Name the class LineDelim.vb and click OK.
  2. Modify the code that Visual Basic .NET creates for you when you add the new class so that it looks like the sample shown below.
    Public Class LineDelim
        Inherits Line
    End Class

You added the Inherits Line statement so that you can use all of the properties and methods of the Line class within this newly created class.

Try It Out

  1. Open the frmLineTest.vb form.
  2. Double-click the GetWord button.
  3. Add the following code to the click event procedure for this button:
    Protected Sub btnFirst_Click(ByVal sender As Object, _
     ByVal e As System.EventArgs) Handles btnFirst.Click
        Dim oLine As LineDelim = New LineDelim()
        oLine.Line = txtLine.Text
        txtFirstWord.Text = oLine.GetWord()
    End Sub
  4. Run the project, and on the form, click the GetWord button. You should see the word "The" appear in the read-only text box next to this button.

The Inherits statement is very powerful. With just one statement, you now have all of the properties and methods of the Line class available in the LineDelim class. Although this new class does not do anything new yet, it shows that all of the code works from the inherited Line class.

Add Additional Functionality

You can now extend the LineDelim class with additional properties and methods. Follow the steps below to add two new properties to the LineDelim class.

  1. Add the two Private variables shown after the Inherits statement you added in the previous section.
    Private mstrDelim As String = " "
    Private mstrOriginal As String
  2. Type in the code below to add the appropriate Property statements for each of these Private variables. You may place this code immediately after the two lines you just entered above.
    Public Property Delimiter() As String
            Return mstrDelim
        End Get
        Set(ByVal Value As String)
            mstrDelim = Value
        End Set
    End Property
    Public ReadOnly Property OriginalLine() As String
            Return mstrOriginal
        End Get
    End Property

You can now use the Delimiter property to both set and get the value from the Private variable mstrDelim.

Sometimes you may not want someone else to change one of your properties. In this case, you can make the property read-only. To do this, leave off the Set statement, and add the ReadOnly attribute to the Property statement. You can see an example of this in the declaration of the OriginalLine property shown in the code above.

Next, create a method called ReplaceAll that will replace all of the spaces in the line of text with the delimiter character passed into the Delimiter property.

Public Function ReplaceAll() As String
    mstrOriginal = MyBase.Line
    Return MyBase.Line.Replace(" ", mstrDelim.ToChar())
End Function

The ReplaceAll method retrieves the original line of text from the Line method of the base class. You used the MyBase.Line syntax to retrieve a property from the base class. The ReplaceAll function places the value of the MyBase.Line property into the Private variable, mstrOriginal, which you just created for this class. The Replace method of the String data type replaces all instances of a string character with the new delimiter character, mstrDelim, which you have set in the Delimiter property.

MyBase Keyword

The MyBase keyword can be used from any subclass to make a call to any property or method in the base class. You can even use it to call the base class' method that you have overridden in the subclass. For example, if you have a method in the base class called ReplaceAll, and you have overridden that method in the subclass, from within the ReplaceAll method in the subclass you may call the ReplaceAll method in the base class.

Try It Out

  1. Open the form frmLineTest.vb.
  2. Double-click Replace to bring up the click event procedure.
  3. Write the code shown below in the click event for the btnReplace button.
    Protected Sub btnReplace_Click( _ 
     ByVal sender As Object, _
     ByVal e As System.EventArgs) Handles btnReplace.Click
        Dim oLine As LineDelim = New LineDelim()
        oLine.Delimiter = txtDelim.Text
        oLine.Line = txtLine.Text
        txtReplace.Text = oLine.ReplaceAll()
    End Sub

    This code will set the Delimiter property to a value entered into the txtDelimiter text box on the sample form. You then invoke the ReplaceAll method to change all of the spaces in the line of text to the new delimiter character.

  4. Press F5 to run the project.
  5. Click Replace. You should see a comma between each word of the sentence in the text box located next to the Replace button.

Override a Method

Now that you have added a Delimiter property, you might want to change the GetWord method in the LineDelim class to use that delimiter instead of the single space that the Line class uses. Because you don't necessarily want to change the base class, you will need to override the capabilities of the GetWord method in the LineDelim class. Before you can create a new GetWord method in the LineDelim class, you need to add a keyword to the GetWord method declaration in the Line class.

  1. In the Solution Explorer window, open the code window for the Line.vb class.
  2. Locate the declaration for the GetWord method (the declaration that has no parameters) as shown below:
    Public Overloads Function GetWord() As String
  3. Add the keyword Overridable to the function declaration, as shown in the listing below (without this keyword, you won't be able to override this method).
    Public Overridable Overloads Function GetWord() As String
  4. Open the LineDelim.vb class and add a new GetWord method using the code shown below.
    Public Overloads Overrides Function GetWord() As String
        Dim astrWords() As String
        astrWords = MyBase.Line.Split(mstrDelim.ToCharArray())
        Return astrWords(0)
    End Function

The Overrides keyword in the function declaration is necessary when you wish to change the functionality of a method from the base class. The GetWord method in the LineDelim class will now use the value of the Delimiter property to separate the words in a sentence.

One side effect of overriding just one of the GetWord methods is that your code can only see this one version of the method. Your code cannot call the other versions of the GetWord method. To make them all visible, you have to override each one, just like you did the LineDelim class.

Try It Out

  1. Run the project by pressing F5.
  2. Put a comma in between each word in the sentence, and fill in the Delimiter text box with a comma.
  3. Click Get Word.

    The first word in the sentence should now appear in the text box next to the Get Word button.

Abstract Classes

In an example from a previous section of this document, you learned to create a Person object because you wanted to deal with a generic person. But you may decide that there is nothing that you can really do with a Person class without first adding some specific behaviors, and/or data. So you make the Person class an abstract class that only defines the generic properties and methods that will be created by subclasses.

The Person class is defined to be an abstract class that can only be inherited from, not an object that is actually created at run time. Each class that inherits from this class, like the Employee class, will create all of the appropriate properties and methods with specific functionality. For example, the Employee class will create an actual Print method, whereas the Person class only defines that a Print method must exist; there is no code associated with the Print method in the Person class.

There are several reasons why you might wish to use an abstract class. They are great for enforcing that the designers of subclasses implement all of the interfaces normally needed by an application. You can add new methods to a child without breaking your client applications, something not possible with interfaces. You can provide a lot of default implementations in the base class to reduce the amount of work a child class has to do.

Interface Inheritance

When you want to create an abstract class, you use the keyword Interface instead of Class. You give the interface a name, and define each of the properties and methods that you expect a subclass to implement. The reason you do this is that there is nothing in the base class that would make sense to implement—it only contains generic data without methods. You are just creating a contract that says any subclass using this interface must adhere to certain rules.

  1. Let's add a new class to the project you have created.
  2. From the Visual Studio menu, click Project and then click Add Class.
  3. Add the following code to this class:
    Interface Person
        Property FirstName() As String
        Property LastName() As String
        Sub Print()
        Sub Talk()
    End Interface

    You can see that you are defining properties and sub procedures just like you would normally define them. The only difference is that you don't fill in any code for them. Now, let's take a look at how you use this Interface in a class definition.

  4. To the same class file that you created in the previous step, add the code you see below.
    Public Class Employee
        Implements Person
        Private mstrFirstName As String
        Private mstrLastName As String
        Property FirstName() As String _
         Implements Person.FirstName
                Return mstrFirstName
            End Get
                mstrFirstName = Value
            End Set
        End Property
        Property LastName() As String _
         Implements Person.LastName
                Return mstrLastName
            End Get
                mstrLastName = Value
            End Set
        End Property
        Sub Print() Implements Person.Print
            ' Some code goes here        
        End Sub
        Sub Talk() Implements Person.Talk
            ' Some code goes here
        End Sub
    End Class

The first line after the definition of the Employee class is Implements Person. This keyword says that you are adhering to the contract set forth in the Person Interface. Now you can define each of the properties and methods in that contract. After each Property statement, you must include the Implements keyword and specify the name of the Interface, a dot (.) and the name of the method/property you are implementing. Visual Basic .NET will keep track of each of these interfaces, and until each one of the interfaces is created, it will not allow you to compile the application.

If you want to run the code, you need to create the appropriate sub procedures, because they are left blank in the above sample. After you create each of these, you will be able to declare a new Employee object and use the Employee object just like any other object you normally create and use.

Choosing the Type of Inheritance to Use

Deciding whether to use Implementation or Interface inheritance is not always straightforward. In many cases, you might have to do a little of both. For example, you might add a method definition that must be overridden by a subclass to the Line class. You implement this by using the MustOverride keyword in a procedure definition.

Public MustOverride Sub Init()

When you add this definition to a Class, it acts similar to an Interface. In the subclass, the Init method must be defined, and it must use the Overrides keyword. Here is an example of how you might define this Init method:

Public Overrides Sub Init()
   mstrDelim = " "
   mstrLine = "Test Line"
End Sub

Once again, notice the use of the Overrides keyword to let the compiler know that this method is the one that overrides the Init method in the parent class.

Note   Check the online Help in the Microsoft .NET Framework for design guidelines to help you make decisions about the types of inheritance to use.

Stopping Inheritance

In some instances you may not wish other classes to be derived from your class. If this is the case, you can stop inheritance on a class by using the keyword NotInheritable.

Public Class NotInheritable Employee
   ' Class definition
End Class

What's New Since Visual Basic 6.0?

Using Visual Basic .NET, you can inherit from all the classes that ship with the .NET Framework. You can create your own classes that inherit from existing classes and add or remove functionality using simple changes to code.


In this document, you learned how to inherit from a base class. You added additional properties to the base class, and used the Overrides keyword to replace functionality defined in the base class. You also learned to use the MyBase keyword to call methods in the base class, thereby extending what the base class can do. Inheritance is not appropriate for all your applications, but you will find that used correctly it can be a powerful tool.

About the Author

Paul D. Sheriff is the owner of PDSA, Inc., a custom software development and consulting company in Southern California. Paul is the MSDN Regional Director for Southern California, is the author of a book on Visual Basic 6 called Paul Sheriff Teaches Visual Basic, and has produced over 72 videos on Visual Basic, SQL Server, .NET and Web Development for Keystone Learning Systems. Paul has co-authored a book entitled ASP.NET Jumpstart. Visit the PDSA, Inc. Web site ( for more information.

About Informant Communications Group

Informant Communications Group, Inc. ( is a diversified media company focused on the information technology sector. Specializing in software development publications, conferences, catalog publishing and Web sites, ICG was founded in 1990. With offices in the United States and the United Kingdom, ICG has served as a respected media and marketing content integrator, satisfying the burgeoning appetite of IT professionals for quality technical information.

Copyright © Informant Communications Group and Microsoft Corporation

Technical Editing: PDSA, Inc.