Reflection and generic types

Question

I'm writing some code for a class constructor which loops through all the properties of the class and calls a generic static method which populates my class with data from an external API. So I've got this as an example class:

public class MyClass{
  public string Property1 { get; set; }
  public int Property2 { get; set; }
  public bool Property3 { get; set; }

  public static T DoStuff<T>(string name){
    // get the data for the property from the external API
    // or if there's a problem return 'default(T)'
  }
}

Now in my constructor I want something like this:

public MyClass(){
  var properties = this.GetType().GetProperties();
  foreach(PropertyInfo p in properties){
    p.SetValue(this, DoStuff(p.Name), new object[0]);
  }
}

So the above constructor will thrown an error because I'm not supplying the generic type.

So how do I pass in the type of the property in?

Answer 1

Do you want to call DoStuff<T> with T = the type of each property? In which case, "as is" you would need to use reflection and MakeGenericMethod - i.e.

    var properties = this.GetType().GetProperties();
    foreach (PropertyInfo p in properties)
    {
        object value = typeof(MyClass)
            .GetMethod("DoStuff")
            .MakeGenericMethod(p.PropertyType)
            .Invoke(null, new object[] { p.Name });
        p.SetValue(this, value, null);
    }

However, this isn't very pretty. In reality I wonder if it wouldn't be better just to have:

static object DoStuff(string name, Type propertyType);
... and then
object value = DoStuff(p.Name, p.PropertyType);

What does the generics give you in this example? Note that value-types will still get boxed etc during the reflection call - and even then boxing isn't as bad as you might think.

Finally, in many scenarios, TypeDescriptor.GetProperties() is more appropriate than Type.GetProperties() - allows for flexible object models etc.

Answer 2

Was your constructor code meant to read like this:

public MyClass(){
  var properties = this.GetType().GetProperties();
  foreach(PropertyInfo p in properties){
    p.SetValue(this, DoStuff(p.Name), new object[0]);
  }
}

? Note the DoStuff instead of MyClass.

If so, the problem is that you're trying to use generics when they're really not applicable. The point of generics (well, one of the points) is to use compile-time type safety. Here you don't know the type at compile time! You could call the method by reflection (fetching the open form and then calling MakeGenericMethod) but that's pretty ugly.

Does DoStuff really need to be generic in the first place? Is it being used from elsewhere? The parameter to PropertyInfo.SetValue is just object, so you'd still get boxing etc even if you could call the method generically.

Answer 3

If you don't use DoStuff from another place, I also suggest to write a non-generic method.

Maybe you created the generic method to be able to use default(T). To replace that in a non-generic method, you can use Activator.CreateInstance(T) for value types and null for reference types:

object defaultResult = type.IsValueType ? Activator.CreateInstance(type) : null

Answer 4

After playing with the solution from @Marc I also had some problems with overload methods. I found a solution which results in fooling around with property count and the like.

I put a post on my blog here: http://www.aaron-powell.com/blog.aspx?id=1257

Answer 5

Hi all ,

does anyone knows hot to invoke "Cast < G > ()" with reflection(Invoke/invokeMember) in case of the IList < P > object type ?

example: IList < P > oManager = ne List < P >();

oManger.Cast < M > () ?

br, Milan