blocks|key|1524766|text|在您的情况下，这两种方法的结果完全相同。它将是您从System.Type派生的自定义类型。这里唯一真正的区别是，当您想要从类的实例中获取类型时，您可以使用GetType。如果您没有实例，但知道类型名称(并且只需要实际的System.Type来检查或比较)，则可以使用typeof。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1524767|重要区别|1524768|编辑:让我补充一下，对GetType的调用是在运行时解析的，而typeof是在编译时解析的。|1524769|entityMap^0|P|B|25|7|31|B|3P|6|0|0|B|7|V|6|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|K|$]]

The result of both are exactly the same in your case. It will be your custom type that derives from <code>System.Type</code>. The only real difference here is that when you want to obtain the type from an instance of your class, you use <code>GetType</code>. If you don't have an instance, but you know the type name (and just need the actual <code>System.Type</code> to inspect or compare to), you would use <code>typeof</code>.
<h3>Important difference</h3>
EDIT: Let me add that the call to <code>GetType</code> gets resolved at runtime, while <code>typeof</code> is resolved at compile time.

blocks|key|1524824|text|对于第一个实例，您需要一个实际的实例(即myCustomer)，对于第二个实例，您不需要|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1524825|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

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

blocks|key|1739898|text|是的，如果你有一个从Customer继承的类型，这是有区别的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1739899|class+VipCustomer+:+Customer
{
++.....
}

static+void+Main()
{
+++Customer+c+=+new+VipCustomer();
+++c.GetType();+//+returns+typeof(VipCustomer)
}|code-block|syntax|javascript|1739900|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

<pre><code>class VipCustomer : Customer
{
 .....
}

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

blocks|key|1524903|text|typeof(foo)在编译时转换为常量。foo.GetType()在运行时发生。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1524904|typeof(foo)也可以直接转换为其类型的常量(例如foo)，所以这样做会失败：|1524905|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)|code-block|syntax|javascript|1524906|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

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:

<pre><code>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)
</code></pre>

blocks|key|1524977|text|typeof在编译时执行，而GetType在运行时执行。这就是这两种方法的不同之处。这就是为什么在处理类型层次结构时，只需运行GetType就可以找到类型的确切类型名。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1524978|public+Type+WhoAreYou(Base+base)
{
+++base.GetType();
}|code-block|syntax|javascript|1524979|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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.

<pre><code>public Type WhoAreYou(Base base)
{
 base.GetType();
}
</code></pre>

blocks|key|1525056|text|typeof运算符接受一个类型作为参数。它是在编译时解析的。在对象上调用GetType方法，并在运行时解析该方法。第一个是当你需要使用一个已知的Type时使用的，第二个是在你不知道一个对象是什么的时候获取它的类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1525057|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+|code-block|syntax|javascript|1525058|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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.

<pre><code>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 
</code></pre>

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

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

我在我维护的一些代码中看到过这两种方法，但不知道有什么不同。有吗？让我补充一下，myCustomer是Customer的一个实例

问C#中的myCustomer.GetType()和typeof(Customer)有什么区别？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的myCustomer.GetType()和typeof(Customer)有什么区别？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的myCustomer.GetType()和typeof(Customer)有什么区别？
EN