You need to determine all of the base types that make up a specific type. Essentially, you need to determine the inheritance hierarchy of a type starting with the base (least derived) type and ending with the specified (most derived) type.
Use the DisplayTypeHierarchy
method to display the
entire inheritance hierarchy for all types existing in an assembly
specified by the asmPath
parameter. Its source
code is:
public static void DisplayTypeHierarchy (string asmPath) { Assembly asm = Assembly.LoadFrom(asmPath); foreach(Type asmType in asm.GetTypes( )) { // Recurse over all base types Console.WriteLine ("Derived Type: " + asmType.FullName); Console.WriteLine ("Base Type List: " + GetBaseTypeList(asmType)); Console.WriteLine ( ); } }
DisplayTypeHierarchy
in turn calls
GetBaseTypeList
, a private method that uses
recursion to get all base types. Its source code
is:
private static string GetBaseTypeList(Type type) { if (type != null) { string baseTypeName = GetBaseType(type.BaseType); if (baseTypeName.Length <= 0) { return (type.Name); } else { return (baseTypeName + "::" + type.Name); } } else { return (""); } }
If you want to obtain only the inheritance hierarchy of a specific
type as a string, use the following
DisplayTypeHierarchy
overload:
public static void DisplayTypeHierarchy(string asmPath,string baseType) { Assembly asm = Assembly.LoadFrom(asmPath); string typeHierarchy = GetBaseTypeList(asm.GetType(baseType)); Console.WriteLine(typeHierarchy); }
To display the inheritance hierarchy of all types within an assembly,
use the first instance of the DisplayTypeHierarchy
method call. To obtain the inheritance hierarchy of a single type as
a string, use the second instance of the
DisplayTypeHierarchy
method call. In this
instance, we are looking for the type hierarchy of the
CSharpRecipes.Reflection+DerivedOverrides
nested
class:
public static void DisplayInheritanceHierarchyType( ) { Process current = Process.GetCurrentProcess( ); // get the path of the current module string asmPath = current.MainModule.FileName; // a specific type TypeHierarchy.DisplayTypeHierarchy(asmPath, "CSharpRecipes.Reflection+DerivedOverrides"); // all types in the assembly TypeHierarchy.DisplayTypeHierarchy(asmPath); }
These methods result in output like the following:
Derived Type: CSharpRecipes.Reflection Base Type List: Object::Reflection Derived Type: CSharpRecipes.Reflection+BaseOverrides Base Type List: Object::BaseOverrides Derived Type: CSharpRecipes.Reflection+DerivedOverrides Base Type List: Object::BaseOverrides::DerivedOverrides
This output shows that when looking at the Reflection class in the
CSharpRecipes
namespace, its base type list (or
inheritance hierarchy) starts with Object
(like
all types in .NET). The nested class BaseOverrides
also shows a base type list starting with Object
.
The nested class DerivedOverrides
shows a more
interesting base type list, where DerivedOverrides
derives from BaseOverrides
, which derives from
Object
.
Unfortunately, no property of the Type
class
exists to obtain the inheritance hierarchy of a type. The
DisplayTypeHierarchy
methods in this recipe allow
you to obtain the inheritance hierarchy of a type. All that is
required is the path to an assembly and the name of the type whose
inheritance hierarchy is to be obtained. The
DisplayTypeHierarchy
method requires only an
assembly path since it displays only the inheritance hierarchy for
all types within that assembly.
The core code of this recipe exists in the
GetBaseTypeList
method. This is a recursive method that walks each inherited type
until it finds the ultimate base class—which is always the
object
class. Once it arrives at this ultimate
base class, it returns to its caller. Each time the method returns to
its caller, the next base class in the inheritance hierarchy is added
to the string until the final GetBaseTypeList
method returns the completed string.