What is the difference between myCustomer.GetType() and typeof(Customer) in C#?

Question

I've seen both done in some code I'm maintaining, but don't know the difference. Is there one?

let me add that myCustomer is an instance of Customer

Answer 1

The result of both are exactly the same in your case. It will be your custom type that derives from System.Type. The only real difference here is that when you want to obtain the type from an instance of your class, you use GetType. If you don't have an instance, but you know the type name (and just need the actual System.Type to inspect or compare to), you would use typeof.

Important difference

EDIT: Let me add that the call to GetType gets resolved at runtime, while typeof is resolved at compile time.

Answer 2

GetType() is used to find the actual type of a object reference at run-time. This can be different from the type of the variable that references the object, because of inheritance. typeof() creates a Type literal that is of the exact type specified and is determined at compile-time.

Answer 3

Yes, there is a difference if you have an inherited type from Customer.

class VipCustomer : Customer
{
  .....
}

static void Main()
{
   Customer c = new VipCustomer();
   c.GetType(); // returns typeof(VipCustomer)
}

Answer 4

For the first, you need an actual instance (ie myCustomer), for the second you don't

Answer 5

typeof(foo) is converted into a constant during compiletime. foo.GetType() happens at runtime.

typeof(foo) also converts directly into a constant of its type (ie foo), so doing this would fail:

public class foo
{
}

public class bar : foo
{
}

bar myBar = new bar();

// Would fail, even though bar is a child of foo.
if (myBar.getType == typeof(foo))

// However this Would work
if (myBar is foo)

Answer 6

typeof is executed at compile time while GetType at runtime. That's what is so different about these two methods. That's why when you deal with type hierarchy, you can find out the exact type name of a type simply by running GetType.

public Type WhoAreYou(Base base)
{
   base.GetType();
}

Answer 7

The typeof operator takes a type as a parameter. It is resolved at compile time. The GetType method is invoked on an object and is resolved at run time. The first is used when you need to use a known Type, the second is to get the type of an object when you don't know what it is.

class BaseClass
{ }

class DerivedClass : BaseClass
{ }

class FinalClass
{
    static void RevealType(BaseClass baseCla)
    {
        Console.WriteLine(typeof(BaseClass));  // compile time
        Console.WriteLine(baseCla.GetType());  // run time
    }

    static void Main(string[] str)
    {
        RevealType(new BaseClass());

        Console.ReadLine();
    }
}
// *********  By Praveen Kumar Srivastava