Common Type System—Implementation Inheritance

Visual C# Tutorials

.NET Framework Tutorials

Common Type System Type Systems Intro § Types and Objects § Type Unification § Reference, Value Types § Accessibility, Visibility § Type Members § Fields § Methods § Locals Overloading Argument Passing Style Pass-by-Value and Pass-by-Reference Output Parameters Managed Pointers Variable Argument Methods Methods, Subclassing Virtuals, Overriding New Slots Exception Handlers Constructors, Instantiation § Default Constructors Value Construction Constructor Chaining Field Initialization Type Initializers Unhandled Exceptions Properties § Indexers Mixed Mode Accessibility Events Operator Overloading Coercion Subclassing, Polymorphism Styles of Inheritance § Implementation Inheritance Interface Inheritance Abstract Classes Interfaces § Method Dispatch Multiple Inheritance Private Interface Inheritance Private Inheritance Accessibility Interface Reimplementation Abstract and Interface? Sealing Types and Methods Runtime Type Checking Namespaces: Organizing Types § Define a Namespace Namespace Resolution Special Types § Delegates § CTS Support Co- and Contravariance Anonymous Delegates Custom Attributes Enumerations § Flags-Style Limitations Helper Methods Generics § Further Reading §

This Book Reviewed!

© 2006 Wiley Publishing Inc.

Implementation Inheritance

This is the default inheritance scheme in the CTS whenever you create a subclass of another type. Implementation inheritance means that a subclass gets a copy of all of its base type’s nonprivate members, including method implementations. So the methods defined on the base type, for example, are immediately callable on an instance of the subclass as you would expect. Depending on whether methods are virtual, a subclass might choose to override these methods to supply their own implementation instead of keeping the base type’s existing version. Virtual methods and overriding are topics we discuss in more detail shortly.

As an example of subclassing, consider two types A and B:

class A
{
   public void Foo()
   {
      Console.WriteLine(“A::Foo”);
   }
}
 
class B : A
{
   public void Bar()
   {
      Console.WriteLine(“B::Bar”);
   }
}

Here, B derives from A—using the <Subclass> : <BaseType> syntax—inheriting the public method Foo and extending A by adding a new method Bar. The result is that the type A has a single method Foo, and the type B has two methods, Foo and Bar. Calling Foo on an instance of B just works, and does the same exact thing as A’s version of Foo (prints out "A::Foo")—the creator of B didn’t have to do anything special to enable this. This is a result of the subclass inheriting both the interface and implementation of the base type’s definition of Foo.