Create an instance of a Type, provided as a parameter to a method

Question

The class to instantiate:

public class InstantiateMe
{
    public String foo
    {
        get;
        set;
    }
}

Some pseudo-code:

public void CreateInstanceOf(Type t)
{
    var instance = new t();

    instance.foo = "bar";
}

So far I'm figuring that I need to use reflection to get this done, given the dynamic nature of what I want to achieve.

Here's my success criteria's:

• Create an instance of any type
• Create instances of types without having to invoke their constructor
• Access all public properties

I would greatly appreciate some working example-code. I'm not new to C#, but I've never worked with reflection before.

Answer 1

Try the following to actually create the instance.

Object t = Activator.CreateInstance(t);

It is not possible however, without generics and constraints to statically access the members as shown in your example.

You could do it with the following though

public void CreateInstanceOf<T>() where T : InstantiateMe, new()
{
    T i = new T();
    i.foo = "bar";
}

Answer 2

You'd basically need to use Reflection. Use Activator.CreateInstance() to construct your type and then call InvokeMember() on the type, to set the property:

public void CreateInstanceOfType(Type t)
{
    var instance = Activator.CreateInstance(t); // create instance

    // set property on the instance
    t.InvokeMember(
        "foo", // property name
        BindingFlags.SetProperty,
        null,
        obj,
        new Object[] { "bar" } // property value
    );
}

To access all the properties of the generic type and set/get them, you can use GetProperties() which returns a PropertyInfo collection, which you can iterate through:

foreach (PropertyInfo property in type.GetProperties())
{ 
    property.GetValue() // get property
    property.SetValue() // set property
}

Also, see the documentation for more ways of using InvokeMember().

Answer 3

Since you have the type you want to instantiate, you can use a generic helper method for that:

public static T New() where T : new()
{
    return new T();
}

Else if you are pulling out the type of some where else (like a dynamically loaded assembly) and you have not access to the type directly (it is some sort of meta programming or reflected data) you should use reflection.