CONSTRUCTING GENERICS THROUGH REFLECTION (LIST OF MIXED TYPES EXAMPLE)

.net 2.0+ Generic classes make code size much smaller and casting objects (boxing) a cinch. However, currently there are some unsupported IDE options when trying to cast objects to and from generic objects that use mixed object types (inherited from a generic type specifier). Fear not, using reflection we can bypass the IDE and supply the users with strongly typed objects.

1. The problem: Lets say I want to construct a generic object, but all I have is a Type object
2. instance. The problem with the syntax of the IDE is that you must specify a keyword type
3. to a generic declaration not a Type object. For example:
5. public IList GetListFromType(Type memberType)
6. {
7. return new MyList<memberType>();
8. }
10. This will not compile.
11. Also as of .net 4.0, generic indexers are not supported, therefore:
13. public T this<T>[int index]
14. {
15. get
16. {
17. object ret = MixedList[index];
18. if (ret is T)
19. return (T)ret;
20. return null;
21. }
22. }
24. ...Will also not compile. This is somewhat annoying since we want to have a specific
25. Strongly Typed object returned from a collection of mixed object types only (easy filtering).
27. To allow this we turn to reflection. We still have generic casting restrictions, so we
28. cannot cast a Dictionary<B,A> to a Dictionary<A,A> even if class B is derived from
29. class A. The only way to fix this is through interfaces. We must return an interface
30. that is used by the derived classed, but we should be using interfaces for common public
31. functionality between derived classes anyway. So the solution is:
33. class A { }
35. class B : A { }
37. Interface IListAB
38. {
39. int Count { get; }
40. }
42. class MyList<T> : List<T>, IListAB
43. {
44. public MyList()
45. {
46. }
47. }
49. IListAB NewListByType(Type elementType)
50. {
51. Type classType = Type.GetType(this.GetType().Namespace) + ".MyList`1", false);
52. Type genClassType = classType.MakeGenericType(elementType);
53. ConstructorInfo ctor = genClassType.GetConstructors()[0]; //get single public constructor
54. return (IListAB)ctor.Invoke(new object[] {});
55. }
57. From this method, you are returned a strongly-typed List as an interface reference. Notice
58. that we are looking up the class constructor by fully qualified name and the `1 after the
59. name of the generic class. The 1 indicates how many generic type arguments are used in the
60. class (a Dictionary<T1,T2> would have 2, and you would pass these types to the
61. MakeGenericType() function). Using further reflection we can even see what type of generic
62. derivation the list is a type of, or we could simply put a method in the interface that
63. returns this information based on the implementation of the class.