C# 4 and .NET 4

Using reflection ❘ 341
ProPerTy
Name
FullName
Namespace
reTurns
The name of the data type
The fully qualified name of the data type (including the namespace name)
The name of the namespace in which the data type is defined
Second, it is possible to retrieve references to further type objects that represent related classes, as shown in
the following table.
ProPerTy
BaseType
UnderlyingSystemType
reTurns TyPe referenCe CorresPonding To
Immediate base type of this type
The type that this type maps to in the .NET runtime (recall that certain .NET base
types actually map to specific predefined types recognized by IL)
A number of Boolean properties indicate whether this type is, for example, a class, an enum, and so
on. These properties include IsAbstract, IsArray, IsClass, IsEnum, IsInterface, IsPointer,
IsPrimitive (one of the predefined primitive data types), IsPublic, IsSealed, and IsValueType. For
example, using a primitive data type:
Type intType = typeof(int);
Console.WriteLine(intType.IsAbstract);
Console.WriteLine(intType.IsClass);
Console.WriteLine(intType.IsEnum);
Console.WriteLine(intType.IsPrimitive);
Console.WriteLine(intType.IsValueType);
Or using the Vector class:
Type vecType = typeof(Vector);
Console.WriteLine(vecType.IsAbstract);
Console.WriteLine(vecType.IsClass);
Console.WriteLine(vecType.IsEnum);
Console.WriteLine(vecType.IsPrimitive);
Console.WriteLine(vecType.IsValueType);
// writes false
// writes false
// writes false
// writes true
// writes true
// writes false
// writes true
// writes false
// writes false
// writes false
Finally, you can also retrieve a reference to the assembly that the type is defined in. This is returned as a
reference to an instance of the System.Reflection.Assembly class, which is examined shortly:
Methods
Type t = typeof (Vector);
Assembly containingAssembly = new Assembly(t);
Most of the methods of System.Type are used to obtain details of the members of the corresponding data
type — the constructors, properties, methods, events, and so on. Quite a large number of methods exist, but
they all follow the same pattern. For example, two methods retrieve details of the methods of the data type:
GetMethod() and GetMethods(). GetMethod() returns a reference to a System.Reflection.MethodInfo
object, which contains details of a method. GetMethods() returns an array of such references. The
difference is that GetMethods() returns details of all the methods, whereas GetMethod() returns details of
just one method with a specified parameter list. Both methods have overloads that take an extra parameter,
a BindingFlags enumerated value that indicates which members should be returned — for example,
whether to return public members, instance members, static members, and so on.
For example, the simplest overload of GetMethods() takes no parameters and returns details of all the
public methods of the data type:
Type t = typeof(double);
MethodInfo[] methods = t.GetMethods();
foreach (MethodInfo nextMethod in methods)
{
// etc.
}
www.it-ebooks.info