Activator.CreateInstance<T> Vs new

Question

Is there any difference between following two ways of creating an object.

Student s1 = Activator.CreateInstance<Student>();
Student s1 = new Student();

• Is there any difference in , the way constructor is called ? initializing the memory ?
• As per my understanding, the first method looks completely redundant to me. If programmer knows data type during design time, he will anyway use the second method.

Answer 1

No, Activator.CreateInstance<T> simply calls the default constructor under the covers. The only difference between your examples is an extra method call to CreateInstance<T>.

From Activator.CreateInstance<T>:

Creates an instance of the type designated by the specified generic type parameter, using the parameterless constructor.

Answer 2

Calling new is better performance-wise CreateInstance probably uses reflection which is slow.
If you know the type during design time - use new, even if the two calls were exactly the same (they're not!) why over-complicate your code?

Use Activator.CreateInstance only when you do not know the type of T in design time and you need run-time resolution of the type.

Answer 3

I wouldn't call Activator.CreateInstance() redundant.

If you know the type, yes, you'd just use new. However, in situations requiring dynamic loading of unknown types from plugin frameworks or where the type is parsed from a string (from, say, a settings-file), it's extremely useful.

And to answer the question as to the difference between the two, no, under the hood there is no real difference between calling new T() and Activator.CreateInstance<T>(), as has already been pointed out by Andrew Hare.

EDIT: Never mind, I've confused the generic CreateInstance<T>() with the otherwise more normally used CreateInstance(Type type)

Answer 4

This overload of the "Activator.CreateInstance" method is used by compilers to implement the instantiation of types specified by type parameters using generics.

Say you have the following method:

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

The compiler will convert the "return new T();" to call "CreateInstance".

In general, there is no use for the CreateInstance in application code, because the type must be known at compile time. If the type is known at compile time, normal instantiation syntax can be used (new operator in C#, New in Visual Basic, gcnew in C++).

More Info: http://msdn.microsoft.com/en-us/library/0hcyx2kd.aspx