Dear Objects - How do I construct thee? Let me count the ways.

Typical construction

The standard way to create a new instance of an object is to use the new keyword.

var instance = new CoolObject();
var instance = new CoolObject(someParameter);

This is great when you know the object you’re constructing.

Reflection

You can also use reflection to create a new instance of an object. This is a little more involved.

//Here's a sample constructor
public CoolObject() { }

Type[] arrayOfTypeParameters = null;
var constructorInfo = typeof(CoolObject).GetConstructor(BindingFlags.Instance, null, arrayOfTypeParameters, null);

If we want a specific constructor with parameters we can make a call like the following

public CoolObject(bool isCool) { }

Type[] arrayOfTypeParameters = new [] { typeof(bool) };
var constructorInfo = typeof(CoolObject).GetConstructor(BindingFlags.Instance, null, arrayOfTypeParameters, null);

With the constructorInfo we can now invoke the constructor to return our object.

var instance = (CoolObject)constructorInfo.Invoke(null);

Or with a parameter

var instance = (CoolObject)constructorInfo.Invoke(new [] { false });

With this method we can invoke private, protected and public constructors.

Activator.CreateInstance/Assembly.CreateInstance

These are both technically shortcuts to the Reflection method above. Assembly.CreateInstance calls Activator.CreateInstance which calls ConstructorInfo.Invoke. You can, however, use a string for the type you wish to construct.

var instance = (CoolObject)Activator.CreateInstance("MyAwesomeProgram.CoolObject");
var instance = (CoolObject)Assembly.GetExecutingAssembly().CreateInstance("MyAwesomeProgram.CoolObject");

One caveat with the Assembly method is you must know which assembly contains the type you wish to instantiate. You can do a couple things here.

//this retrieves the assembly that contains your type
var assembly = Assembly.LoadFile(@"c:\my.dll");
var type = assembly.GetType("MyAwesomeProgram.CoolObject");
var instance = Activator.CreateInstance(type);

//or
var instance = assembly.CreateInstance("MyAwesomeProject.CoolObject");

You can also pass type info directly or even use generics.

var instance = Activator.CreateInstance(typeof(CoolObject));
var instance = Activator.CreateInstance<CoolObject>();

The latter call is especially useful when dealing with generics.

new T()

Sometimes all you have is a generic T and you want to create a new instance of T that has a default constructor. We need to declare that T can be constructed. We can do this with the new() constraint on T.

public CoolObject() { }

public T MakeObject<T>() where T : new() 
{
    return new T();
}

There’s a way to return the default value of T. However this returns the default value for an object which in most cases is null. Value types such as Int32 will return their default value, which in this case is 0.

FormatterServices.GetUninitializedObject

I covered this in my previous blog post. However here’s the short version.

var instance = (CoolObject)FormatterServices.GetUninitializedObject(typeof(CoolObject));

This particular one is strange though. It does not call any constructors. It does not initialize the object nor any of it’s fields/properties except to their default values.

Final

Hopefully this helps you. If I missed any please leave a comment!

-Ben Dornis