CODEWITHSUNDEEP
.netreflection
Palani
Palani

Reputation: 9042

Activator.CreateInstance<T> Vs new

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

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

Upvotes: 39

Views: 21712

Answers (5)

Dror Helper
Dror Helper

Reputation: 30790

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.

Upvotes: 5

Dave Cousineau
Dave Cousineau

Reputation: 13158

One large difference is that 

Student s1 = new Student();

will not compile if there is no default constructor on Student, whereas

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

will compile even if Student does not have a default constructor. (It will compile, and let you run the program, but if there is no matching constructor you will get an exception, whereas the constructor call will not even compile if the constructor does not exist.)

Similarly, the CreateInstance call is an implicit use of the class, so, for example, Resharper will not know that you are instantiating it, and might tell you that the class is never instantiated.

As mentioned in other answers, the CreateInstance call also allows for the use of a generic type parameter:

T s1 = Activator.CreateInstance<T>();

though you would probably be better off using a new type constraint, since it would give you compile-time assurance that there actually is a constructor to be called.

The Activator.CreateInstance(Type, ...) overloads are much more useful, however.

Upvotes: 6

Chris Pietschmann
Chris Pietschmann

Reputation: 29895

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

Upvotes: 18

J. Steen
J. Steen

Reputation: 15578

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)

Upvotes: 10

Andrew Hare
Andrew Hare

Reputation: 351516

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.

Upvotes: 4

Related Questions