typeof(T) vs new T().GetType()

Are the two expressions guaranteed to be identical?

In a generic method Foo<T> where T : new() ... is this expression always true?

typeof(T) == new T().GetType()

I don't see how it could be false, but perhaps I'm missing an edge-case.

I don't think this is addressed in any of the following related questions:

• https://stackoverflow.com/questions/983030/type-checking-typeof-gettype-or-is
• https://stackoverflow.com/questions/11312111/when-and-where-to-use-gettype-or-typeof
• https://stackoverflow.com/questions/4537945/what-is-the-difference-of-getting-type-by-using-gettype-and-typeof

typeof(T) and new T().GetType() are not quite identical. In fact, new T().GetType() is not "safe".

Consider when T is an int? or something similar, then new T() will result in null - actually an instance of int? with HasValue = false, which is actually a struct. Boxing a nullable value type that has no value results in null, and calling a method on it that is inherited from object will box the value first. So new T().GetType() throws a null reference exception in this case.

> is this expression always true
> typeof(T) == new T().GetType()

It might be that it is never false (ie either true or does not evaluate to a value), but I may be overlooking some other strange edge case.

> In a generic method Foo<T> where T : new() ... is this expression always true?
>
> typeof(T) == new T().GetType()

Sadly, no. For reference types (including nullable reference types) with default constructors then yes, but this doesn't hold true for nullable value types.

Where T is int? or DateTime? or any other nullable value type, the result of new T() is null. Calling GetType() on null is of course going to result in a NullReferenceException. But let's try something else:

static Type? WhichType<T>(T value) => value?.GetType();

This won't throw an exception, but may return null. Now let's try it out:

var type1 = WhichType<int?>(0);
var type2 = WhichType((int?)0);

Since nullable value types are treated specially by the C# compiler, it's not entirely clear that the result of calling GetType() on a nullable value type will return the inner type, and it makes some sense. Sadly it doesn't help you much when someone calls your generic method with the wrong type.

And in case you're wondering, it works on any value type not just value primitives:

public struct TestType { }

var type1 = WhichType<DateTime?>(DateTime.Now);
var type2 = WhichType<TestType?>(new TestType());

Where this may be an issue is when you're trying to compare the type of a value with an expected type where T is a nullable value type. In this case you need to use a bit of code to figure things out.

var targetType = typeof(T);
if (targetType.IsConstructedGenericType &&
    targetType.GetGenericTypeDefinition() == typeof(Nullable<>)
)
    targetType = Nullable.GetUnderlyingType(targetType);

This will unwrap the Nullable<> from the outer type if necessary, allowing you to compare it to the an object instance type.

It depends what you mean. If you are instantiating T (your var x = new T();) and then immediately after writing

Type t1 =  x.GetType();

and

if (t1 == typeof(T)) {... } // probably always true by definition

but what if your T is say a non abstract class and has subclass R? Well that changes the picture, doesn't it? I mean GetType() is a run time type (not a static compile type like typeof(T)). So (pseudo-code here below)

var x = new T();
var t1 = x.GetType(); // T 
...
x = new R();
...
bool chk1 = t1 == typeof(T); // true;
t1 = x.GetType(); // R
bool chk2 = t1 == typeof(T); // false

I suppose they're always provide the same result. The difference is in that for typeof you don't have to create new instance of a T which is rather something good.
Also it's semantically more obvious if you go with typeof to check type rather than creating instance of an object.