Object.GetType Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Gets the Type of the current instance.
public:
Type ^ GetType();public Type GetType ();member this.GetType : unit -> TypePublic Function GetType () As TypeReturns
The exact runtime type of the current instance.
Examples
The following code example demonstrates that GetType returns the runtime type of the current instance.
using namespace System;
public ref class MyBaseClass {};
public ref class MyDerivedClass: MyBaseClass{};
int main()
{
MyBaseClass^ myBase = gcnew MyBaseClass;
MyDerivedClass^ myDerived = gcnew MyDerivedClass;
Object^ o = myDerived;
MyBaseClass^ b = myDerived;
Console::WriteLine( "mybase: Type is {0}", myBase->GetType() );
Console::WriteLine( "myDerived: Type is {0}", myDerived->GetType() );
Console::WriteLine( "object o = myDerived: Type is {0}", o->GetType() );
Console::WriteLine( "MyBaseClass b = myDerived: Type is {0}", b->GetType() );
}
/*
This code produces the following output.
mybase: Type is MyBaseClass
myDerived: Type is MyDerivedClass
object o = myDerived: Type is MyDerivedClass
MyBaseClass b = myDerived: Type is MyDerivedClass
*/
using System;
public class MyBaseClass {
}
public class MyDerivedClass: MyBaseClass {
}
public class Test
{
public static void Main()
{
MyBaseClass myBase = new MyBaseClass();
MyDerivedClass myDerived = new MyDerivedClass();
object o = myDerived;
MyBaseClass b = myDerived;
Console.WriteLine("mybase: Type is {0}", myBase.GetType());
Console.WriteLine("myDerived: Type is {0}", myDerived.GetType());
Console.WriteLine("object o = myDerived: Type is {0}", o.GetType());
Console.WriteLine("MyBaseClass b = myDerived: Type is {0}", b.GetType());
}
}
// The example displays the following output:
// mybase: Type is MyBaseClass
// myDerived: Type is MyDerivedClass
// object o = myDerived: Type is MyDerivedClass
// MyBaseClass b = myDerived: Type is MyDerivedClass
type MyBaseClass() = class end
type MyDerivedClass() =
inherit MyBaseClass()
let myBase = MyBaseClass()
let myDerived = MyDerivedClass()
let o: obj = myDerived
let b: MyBaseClass = myDerived
printfn $"mybase: Type is {myBase.GetType()}"
printfn $"myDerived: Type is {myDerived.GetType()}"
printfn $"object o = myDerived: Type is {o.GetType()}"
printfn $"MyBaseClass b = myDerived: Type is {b.GetType()}"
// The example displays the following output:
// mybase: Type is MyBaseClass
// myDerived: Type is MyDerivedClass
// object o = myDerived: Type is MyDerivedClass
// MyBaseClass b = myDerived: Type is MyDerivedClass
' Define a base and a derived class.
Public Class MyBaseClass
End Class
Public Class MyDerivedClass : Inherits MyBaseClass
End Class
Public Class Test
Public Shared Sub Main()
Dim base As New MyBaseClass()
Dim derived As New MyDerivedClass()
Dim o As Object = derived
Dim b As MyBaseClass = derived
Console.WriteLine("base.GetType returns {0}", base.GetType())
Console.WriteLine("derived.GetType returns {0}", derived.GetType())
Console.WriteLine("Dim o As Object = derived; o.GetType returns {0}", o.GetType())
Console.WriteLine("Dim b As MyBaseClass = derived; b.Type returns {0}", b.GetType())
End Sub
End Class
' The example displays the following output:
' base.GetType returns MyBaseClass
' derived.GetType returns MyDerivedClass
' Dim o As Object = derived; o.GetType returns MyDerivedClass
' Dim b As MyBaseClass = derived; b.Type returns MyDerivedClass
Remarks
Because System.Object is the base class for all types in the .NET type system, the GetType method can be used to return Type objects that represent all .NET types. .NET recognizes the following five categories of types:
Classes, which are derived from System.Object,
Value types, which are derived from System.ValueType.
Interfaces, which are derived from System.Object starting with the .NET Framework 2.0.
Enumerations, which are derived from System.Enum.
Delegates, which are derived from System.MulticastDelegate.
For two objects x and y that have identical runtime types, Object.ReferenceEquals(x.GetType(),y.GetType()) returns true. The following example uses the GetType method with the ReferenceEquals method to determine whether one numeric value is the same type as two other numeric values.
int n1 = 12;
int n2 = 82;
long n3 = 12;
Console.WriteLine("n1 and n2 are the same type: {0}",
Object.ReferenceEquals(n1.GetType(), n2.GetType()));
Console.WriteLine("n1 and n3 are the same type: {0}",
Object.ReferenceEquals(n1.GetType(), n3.GetType()));
// The example displays the following output:
// n1 and n2 are the same type: True
// n1 and n3 are the same type: False
open System
let n1 = 12
let n2 = 82
let n3 = 12L
printfn $"n1 and n2 are the same type: {Object.ReferenceEquals(n1.GetType(), n2.GetType())}"
printfn $"n1 and n3 are the same type: {Object.ReferenceEquals(n1.GetType(), n3.GetType())}"
// The example displays the following output:
// n1 and n2 are the same type: True
// n1 and n3 are the same type: False
Module Example
Public Sub Main()
Dim n1 As Integer = 12
Dim n2 As Integer = 82
Dim n3 As Long = 12
Console.WriteLine("n1 and n2 are the same type: {0}",
Object.ReferenceEquals(n1.GetType(), n2.GetType()))
Console.WriteLine("n1 and n3 are the same type: {0}",
Object.ReferenceEquals(n1.GetType(), n3.GetType()))
End Sub
End Module
' The example displays the following output:
' n1 and n2 are the same type: True
' n1 and n3 are the same type: False
Note
To determine whether an object is a specific type, you can use your language's type comparison keyword or construct. For example, you can use the TypeOf…Is construct in Visual Basic or the is keyword in C#.
The GetType method is inherited by all types that derive from Object. This means that, in addition to using your own language's comparison keyword, you can use the GetType method to determine the type of a particular object, as the following example shows.
object[] values = { (int) 12, (long) 10653, (byte) 12, (sbyte) -5,
16.3, "string" };
foreach (var value in values) {
Type t = value.GetType();
if (t.Equals(typeof(byte)))
Console.WriteLine("{0} is an unsigned byte.", value);
else if (t.Equals(typeof(sbyte)))
Console.WriteLine("{0} is a signed byte.", value);
else if (t.Equals(typeof(int)))
Console.WriteLine("{0} is a 32-bit integer.", value);
else if (t.Equals(typeof(long)))
Console.WriteLine("{0} is a 64-bit integer.", value);
else if (t.Equals(typeof(double)))
Console.WriteLine("{0} is a double-precision floating point.",
value);
else
Console.WriteLine("'{0}' is another data type.", value);
}
// The example displays the following output:
// 12 is a 32-bit integer.
// 10653 is a 32-bit integer.
// 12 is an unsigned byte.
// -5 is a signed byte.
// 16.3 is a double-precision floating point.
// 'string' is another data type.
let values: obj[] =
[| 12; 10653L; 12uy
-5y; 16.3; "string" |]
for value in values do
let t = value.GetType()
if t.Equals typeof<byte> then
printfn $"{value} is an unsigned byte."
elif t.Equals typeof<sbyte> then
printfn $"{value} is a signed byte."
elif t.Equals typeof<int> then
printfn $"{value} is a 32-bit integer."
elif t.Equals typeof<int64> then
printfn $"{value} is a 64-bit integer."
elif t.Equals typeof<double> then
printfn $"{value} is a double-precision floating point."
else
printfn $"'{value}' is another data type."
// The example displays the following output:
// 12 is a 32-bit integer.
// 10653 is a 32-bit integer.
// 12 is an unsigned byte.
// -5 is a signed byte.
// 16.3 is a double-precision floating point.
// 'string' is another data type.
Module Example
Public Sub Main()
Dim values() As Object = { 12, CLng(10653), CByte(12),
CSbyte(-5), 16.3, "string" }
For Each value In values
Dim t AS Type = value.GetType()
If t.Equals(GetType(Byte))
Console.WriteLine("{0} is an unsigned byte.", value)
ElseIf t.Equals(GetType(SByte))
Console.WriteLine("{0} is a signed byte.", value)
ElseIf t.Equals(GetType(Integer))
Console.WriteLine("{0} is a 32-bit integer.", value)
ElseIf t.Equals(GetType(Long))
Console.WriteLine("{0} is a 64-bit integer.", value)
ElseIf t.Equals(GetType(Double))
Console.WriteLine("{0} is a double-precision floating point.",
value)
Else
Console.WriteLine("'{0}' is another data type.", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' 12 is a 32-bit integer.
' 10653 is a 32-bit integer.
' 12 is an unsigned byte.
' -5 is a signed byte.
' 16.3 is a double-precision floating point.
' 'string' is another data type.
The Type object exposes the metadata associated with the class of the current Object.
Applies to
See also
Feedback
Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback.
Submit and view feedback for