Common Type System—Subclassing and Polymorphism

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.

Subclassing and Polymorphism

Types can derive from other types, forming a special relationship between two types. We say type B is a subclass of type A if B derives from A. In IL terminology, B extends A. In this example, A is B’s base type (a.k.a. super- or parent type). Types can only have one immediate base type in the CTS; in other words, multiple inheritance is not supported. Interfaces, a topic we discuss in this section, enable multiple interface inheritance, but this is subtly different from what is normally meant as multiple inheritance. Because userdefined structs cannot derive from an arbitrary type (they implicitly derive from System.ValueType and are sealed by default), we just go ahead and say subclass instead of using more precise terminology.

You can express a subtype relation in C# as follows:

class A {}
class B : A {}
class C : A {}

In this example, both B and C are subclasses of A. Of course, we can then go ahead and create additional subclasses of A, or even subclasses of B and C. In IL this looks as follows:

.class private auto ansi beforefieldinit 
   A extends [mscorlib]System.Object {}
.class private auto ansi beforefieldinit
   B extends A {}
.class private auto ansi beforefieldinit
   C extends A {}

When B is a subclass of A, we say that B is polymorphic with respect to A. All this means is that, because A subclass inherits all of the publicly visible traits of its base type, an instance of B can be treated just like an instance of A in a type-safe manner. The reverse is of course not true. We discuss inheritance in more detail shortly.