The abstract class Type, defined in the System namespace, is an abstraction of a .NET CLR type. Every .NET type, be it a .NET-provided type (from value types such as integers and enums to classes and interfaces) or a developer-defined type, has a corresponding unique Type value.
The canonical base class of any .NET type is System.Object. Object (or just object in C#) has built-in support for retrieving the Type associated with any object by calling its GetType( ) method: public class Object { public Type GetType( ); //Other methods } Having GetType( ) present in object allows you to call it on any .NET object: public class MyClass {...} int number = 0; MyClass obj = new MyClass( ); Type type1 = number.GetType( ); Type type2 = obj.GetType( ); Different instances of the same type must return the same Type value: int number1 = 1; int number2 = 2; Type type1 = number1.GetType( ); Type type2 = number2.GetType( ); Debug.Assert(type1 == type2); The typeof operator allows you to retrieve the Type associated with a type directly, without instantiating an object of that type: Type type1 = typeof(int); Type type2 = typeof(MyClass); Type is your gateway to obtaining the metadata associated with a given type. To start, Type.ToString( ) returns the type's name: Type type = typeof(MyClass); string name = type.ToString( ); Debug.Assert(name == "MyClass"); But Type has a lot more to offer. It has more than 100 methods and properties that you can use to obtain metadata about the type. For example, the GetMethods( ) method returns an array of MethodInfo objects describing all the public methods of the type. GetMethods( ) is defined as: public MethodInfo[] GetMethods( ); Example C-1 demonstrates using GetMethods( ) to trace to the output window all the public methods of the class MyClass. Example C-1. Using Type.GetMethods( ) to reflect a type's public methodsusing System.Reflection; public class MyClass { public MyClass( ) {} public void Method1( ) {} public static void Method2( ) {} protected void Method3( ) {} private void Method4( ) {} } //Client code: Type type = typeof(MyClass); MethodInfo[] methodInfoArray = type.GetMethods( ); //Trace all the public methods foreach(MethodInfo methodInfo in methodInfoArray) { Trace.WriteLine(methodInfo.Name); } //Output: GetHashCode Equals ToString Method1 Method2 GetType This example demonstrates a few other key points. GetMethods( ) returns all the public methods of a type (instance or static), including those defined in its base class(es). In its output, Example C-1 lists four public methods of object that are not part of the MyClass definition. GetMethods( ) doesn't return constructors. If you aren't satisfied with this behavior, you can use another version of GetMethods( ) that accepts a parameter telling it how to bind to the type: public abstract MethodInfo[] GetMethods(BindingFlags bindingAttr); The BindingFlags enumeration is a bit-mask enumeration that lets you specify whether to return only instance methods, only static methods, only nonpublic methods, methods defined only in this type (i.e., not inherited), and so on. Once you have obtained a MethodInfo object about a method, you can invoke it, even if it's a protected or private method. Example C-2 demonstrates how to invoke all the private methods of the MyClass class using the late-binding Invoke( ) method of the MethodInfo object. The Invoke( ) method is defined as: public object Invoke(object obj, object[] parameters);
Example C-2 starts by obtaining a Type object from an instance (unlike Example C-1, which uses the class itself). Then it calls GetMethods( ), requesting back only nonpublic instance methods. Note that to invoke only private methods, further filtering is required after calling GetMethods( ), because GetMethods( ) returns both protected and private methods. The additional filtering is done by checking the IsPrivate property of the MethodInfo object. In Example C-2, only Method4( ) is invoked. Invoke( ) accepts the object to invoke the method on, and an array of objects as parameters for the method to invoke. In this example, Method4( ) has no parameters, so a null is passed in to Invoke( ). Example C-2. Invoking only the private methods of an object using reflectionusing System.Reflection; public class MyClass { public MyClass( ) {...} public void Method1( ) {...} public void Method2( ) {...} public static void Method5( ) {...} protected void Method3( ) {...} private void Method4( ) {...} } //Client code MyClass obj = new MyClass( ); Type type = typeof(MyClass); MethodInfo[] methodInfoArray; methodInfoArray = type.GetMethods(BindingFlags.NonPublic|BindingFlags.Instance); //Invoke private methods only foreach(MethodInfo methodInfo in methodInfoArray) { if(methodInfo.IsPrivate) { methodInfo.Invoke(obj,null); } }
Type offers numerous other methods in addition to GetMethods( ). GetMethod( ) returns a MethodInfo object about one particular method. GetConstructors( ) and GetConstructor( ) return ConstructorInfo objects about the type's constructors. GetMember( ) and GetMembers( ) return information about the type's members. GetEvent( ) and GetEvents( ) return information about the events the type supports, and so on. The general form of retrieving the reflection information is Get<Element Name>. Type also offers many properties dealing with what kind of type is reflected: if it's a class or an interface, what its base class type is, and so on. For example: Type type = typeof(MyClass); Debug.Assert(type.IsClass); See the MSDN Library for a complete listing of the Type members. |