Object.GetType Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Type Pobiera wartość bieżącego wystąpienia.

public:
 Type ^ GetType();

public Type GetType ();

member this.GetType : unit -> Type

Public Function GetType () As Type

Zwraca

Type

Dokładny typ środowiska uruchomieniowego bieżącego wystąpienia.

Przykłady

Poniższy przykład kodu pokazuje, że GetType zwraca typ środowiska uruchomieniowego bieżącego wystąpienia.

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

Uwagi

Ponieważ System.Object jest klasą bazową dla wszystkich typów w systemie typów platformy .NET, GetType metoda może służyć do zwracania Type obiektów reprezentujących wszystkie typy platformy .NET. Platforma .NET rozpoznaje następujące pięć kategorii typów:

Klasy, które pochodzą z System.Objectklasy ,
Typy wartości, które pochodzą z System.ValueTypeklasy .
Interfejsy, które pochodzą od System.Object początku od .NET Framework 2.0.
Wyliczenia, które pochodzą z System.Enum.
Delegaci, które pochodzą z System.MulticastDelegate.

W przypadku dwóch obiektów x , y które mają identyczne typy środowiska uruchomieniowego, Object.ReferenceEquals(x.GetType(),y.GetType()) zwraca wartość true. W poniższym przykładzie użyto GetType metody z ReferenceEquals metodą , aby określić, czy jedna wartość liczbowa jest tym samym typem co dwie inne wartości liczbowe.

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

Uwaga

Aby określić, czy obiekt jest określonym typem, możesz użyć słowa kluczowego porównania typów języka lub konstrukcji. Można na przykład użyć TypeOf…Is konstrukcji w Visual Basic lub słowa kluczowego is w języku C#.

Metoda GetType jest dziedziczona przez wszystkie typy pochodzące z Objectklasy . Oznacza to, że oprócz używania słowa kluczowego porównania języka można użyć GetType metody w celu określenia typu określonego obiektu, jak pokazano w poniższym przykładzie.

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.

Obiekt Type uwidacznia metadane skojarzone z klasą bieżącego Objectobiektu .

Dotyczy

Zobacz też

Type

Udostępnij za pośrednictwem