(How)
C^# You Are - 22 April 2007

This weeks topic is reflection and its awesome power.

1. How do you retrieve information about a type?  Answer

   If you have an instance of the type then you can use the GetType method.  Otherwise you can use the Type.GetType static method to retrieve a type by its name.  The returned value in both cases is an instance of Type which contains everything you need to know about a type including its properties, methods and even base class.  Finally you can also use the typeof operator in C#.

   A word of warning.  When retrieving a type always use the full name, including namespace.  The using statement has no affect on reflection.

   int number = 10;
   Type instanceType = number.GetType();
   Type generalType = Type.GetType("System.Int32");
   Type operatorType = typeof(int);
   

2. How do you retrieve information about a method such as its parameters?  Answer

   Once you have a Type instance you can call the GetMethod or GetMethods methods to retrieve either a specific method given its name or all methods.  You can optionally filter on the accessibility or other modifiers of a method such as whether it is static or not.  The return type is MethodInfo which contains information about the method including its parameters.

   The following code retrieves the Parse method of the Int32 class. 

   int number = 10;
   Type intType = number.GetType();
   MethodInfo methParse = intType.GetMethod("Parse");
   

3. How can you invoke a method programmatically through reflection?  Answer

   Once you have the MethodInfo for the method you can invoke it using the Invoke method on the MethodInfo class.  The method requires the target object (or null if the method is static) and an array of parameters for the method.  The method returns an object which represents the return value from the invoked method, if any.

   Here is an example of programmatically invoking the Parse method on an integral value.

   int number = 10;
   Type intType = number.GetType();
   MethodInfo methParse = intType.GetMethod("Parse");
   int newNumber = (int)methParse.Invoke(number, new object[] { "25" });
   

4. How do you get the value of a property programmatically?  Answer

   This is very similar to invoking methods.  However in this case you will use the GetProperty method on Type to get the PropertyInfo instance for the property and then use the GetValue method to retrieve the property value.  As with invoking a method the first parameter is the target object and can be null if the property is static.  Parameters
   can be passed as well if the property is index. 

   Here is an example of getting the length of a string programmatically.

   string name = "Testing";
   Type stringType = name.GetType();
   PropertyInfo propLength = stringType.GetProperty("Length");
   int len = (int)propLength.GetValue(name, null);
   

5. How do you set the value of a property?  Answer

   Almost identical code to getting but you will instead call SetValue.  Be careful about the passed value though.  The value that you pass should be directly compatible with the property value otherwise a runtime error will occur.  Compilers go out of their way to ensure that property assignments work through type coercion or whatever but the runtime makes no such guarantees.  Play it safe and make sure the value matches the property type.

   TextBox box = new TextBox();
   Type typeBox = box.GetType();
   PropertyInfo propName = typeBox.GetProperty("Name");
   propName.SetValue(box, "box1", null);
   

6. How can you programmatically hook up to an event of an object through reflection?  Answer

   This is a little tougher.  Subscribing and unsubscribing to events are handled differently by each language.  However in all cases such processes map to method invocations.  Unfortunately the name of the method can vary.  Therefore the safest route is to get access to the event, request its add (or remove) method and then invoke the method as normal.  But this requires a lot of code.  Fortunately the EventInfo class that describes an event exposes the AddEventHandler and RemoveEventHandler methods to add and remove handlers from the event.

   Here is an example of hooking up to a button's click event.

   Button btn = new Button();
   EventInfo evtClick = btn.GetType().GetEvent("Click");
   evtClick.AddEventHandler(btn, new EventHandler(OnbuttonClicked));
   

7. How can you determine whether a type is generic or not?   Answer

   It really depends on what you mean by a generic type.  In .NET a generic type definition is used to refer to a type that contains one or more type parameters that have not yet been assigned a value.  An open constructed type is a type that contains at least one type parameter that is not yet specified.  A closed constructed type is a type that has all type parameters assigned a value.  A generic type, in .NET, is a generic type definition, an open constructed type or a closed constructed type.

   The Type class exposes several properties to determine which of the above conditions apply.  The IsGenericType property is true if the type represents any of the above cases.  The IsGenericTypeDefinition determines if a type is a generic type definition and therefore can not be instantiated.  The ContainsGenericParameter property determines if the type is opened or closed.  If it is true then the type is open otherwise it is closed and can be instantiated.

   The following code examines several different types to demonstrate the various states of the properties.

   class TestDictionary : Dictionary { }
   
   class Program
   {
      static void PrintGenericInfo ( Type type )
      {
         Console.WriteLine("Type = " + type.FullName);
         Console.WriteLine("   IsGenericType = " + type.IsGenericType);
         Console.WriteLine("   IsGenericTypeDefinition = " + type.IsGenericTypeDefinition); 
         Console.WriteLine("Constructed type = {0}", type.ContainsGenericParameters ? "Open" : "Closed");
      }
   
      static void Main ( string[] args )
      {
         PrintGenericInfo(typeof(string));   // , false, false, closed
         PrintGenericInfo(Type.GetType("System.Collections.ObjectModel.Collection`1"));   // , true, true, open
         PrintGenericInfo(new Collection<int>().GetType());    // ,true, false, closed
   
         Type type = Type.GetType("ConsoleApplication1.TestDictionary`1"); 
         PrintGenericInfo(type.BaseType);     // ,true, false, open
      }
   }

8. How can you create an instance of a generic type?  Answer

   To create an instance of a generic type you need only specify the types to use for each type parameter.  The MakeGenericType method can be used for this.  Doing so, in effect, creates a new type so the return value is a Type instance representing a closed generic type.

   The following example programmatically creates an instance of an integer collection.

   Type genericType = Type.GetType("System.Collections.ObjectModel.Collection`1");
   Type concreteType = genericType.MakeGenericType(typeof(int));
   
   object coll = Activator.CreateInstance(concreteType);
   

9. How can you retrieve the type parameters for a generic type definition?  Answer

   The GetGenericArguments method can be used to retrieve the type parameters.  For open types the arguments will be a mix of actual types and type parameters.  Type parameters are used to identify the types that must still be provided.  The IsGenericParameter property on the type identifies it as a generic type parameter that has not yet been specified.

10. How would you use reflection to completely generalize your application?  Answer

    In short, you never would normally.  Reflection should be used sparingly and only when there is absolutely no other way to define your application in a meaningful manner.  In general you should use interfaces and base classes to represent the types that you must access.  Interfaces and base classes allow you to target concrete types that might not exist yet.  The biggest benefit is strong type-checking at compile time.  Reflection provides only runtime errors.  Reflection is also expensive to use even in the most optimal case.  Prefer interfaces and base classes to reflection.

    However there are some cases where reflection can not be avoided.  .NET uses reflection quite a bit.  ASP.NET theming is based off reflection as is the property grid control available for WinForms apps.  Structure equality uses reflection to provide a default, albeit slow, implementation.  Reflection is a great tool but should be used sparingly.