RuntimeTypeHandle Estrutura

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa um tipo usando um token de metadados internos.

public value class RuntimeTypeHandle

public value class RuntimeTypeHandle : System::Runtime::Serialization::ISerializable

public value class RuntimeTypeHandle : IEquatable<RuntimeTypeHandle>, System::Runtime::Serialization::ISerializable

public struct RuntimeTypeHandle

public struct RuntimeTypeHandle : System.Runtime.Serialization.ISerializable

public struct RuntimeTypeHandle : IEquatable<RuntimeTypeHandle>, System.Runtime.Serialization.ISerializable

[System.Serializable]
public struct RuntimeTypeHandle : System.Runtime.Serialization.ISerializable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct RuntimeTypeHandle : System.Runtime.Serialization.ISerializable

type RuntimeTypeHandle = struct

type RuntimeTypeHandle = struct
    interface ISerializable

[<System.Serializable>]
type RuntimeTypeHandle = struct
    interface ISerializable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type RuntimeTypeHandle = struct
    interface ISerializable

Public Structure RuntimeTypeHandle

Public Structure RuntimeTypeHandle
Implements ISerializable

Public Structure RuntimeTypeHandle
Implements IEquatable(Of RuntimeTypeHandle), ISerializable

Herança: Object

ValueType
RuntimeTypeHandle

Atributos: SerializableAttribute ComVisibleAttribute

Implementações: ISerializable IEquatable<RuntimeTypeHandle>

Exemplos

O exemplo a seguir demonstra como obter um RuntimeTypeHandle de um tipo ou de um objeto e como transformar o identificador de volta em um tipo.

using namespace System;
using namespace System::Reflection;

public ref class MyClass1
{
private:
    int x;

public:
    int MyMethod()
    {
        return x;
    }
};

int main()
{
    MyClass1^ myClass1 = gcnew MyClass1;
   
    // Get the RuntimeTypeHandle from an object.
    RuntimeTypeHandle myRTHFromObject = Type::GetTypeHandle( myClass1 );
   
    // Get the RuntimeTypeHandle from a type.
    RuntimeTypeHandle myRTHFromType = MyClass1::typeid->TypeHandle;

    Console::WriteLine( "\nmyRTHFromObject.Value:  {0}", myRTHFromObject.Value );
    Console::WriteLine( "myRTHFromObject.GetType():  {0}", myRTHFromObject.GetType() );
    Console::WriteLine( "Get the type back from the handle..." );
    Console::WriteLine( "Type::GetTypeFromHandle(myRTHFromObject):  {0}", 
        Type::GetTypeFromHandle(myRTHFromObject) );

    Console::WriteLine( "\nmyRTHFromObject.Equals(myRTHFromType):  {0}", 
        myRTHFromObject.Equals(myRTHFromType) );

    Console::WriteLine( "\nmyRTHFromType.Value:  {0}", myRTHFromType.Value );
    Console::WriteLine( "myRTHFromType.GetType():  {0}", myRTHFromType.GetType() );
    Console::WriteLine( "Get the type back from the handle..." );
    Console::WriteLine( "Type::GetTypeFromHandle(myRTHFromType):  {0}", 
        Type::GetTypeFromHandle(myRTHFromType) );
}

/* This code example produces output similar to the following:

myRTHFromObject.Value:  3295832
myRTHFromObject.GetType():  System.RuntimeTypeHandle
Get the type back from the handle...
Type::GetTypeFromHandle(myRTHFromObject):  MyClass1

myRTHFromObject.Equals(myRTHFromType):  True

myRTHFromType.Value:  3295832
myRTHFromType.GetType():  System.RuntimeTypeHandle
Get the type back from the handle...
Type::GetTypeFromHandle(myRTHFromType):  MyClass1
 */

using System;
using System.Reflection;

public class MyClass1
{
    private int x=0;
    public int MyMethod()
    {
        return x;
    }
}

public class MyClass2
{
    public static void Main()
    {
        MyClass1 myClass1 = new MyClass1();

        // Get the RuntimeTypeHandle from an object.
        RuntimeTypeHandle myRTHFromObject = Type.GetTypeHandle(myClass1);
        // Get the RuntimeTypeHandle from a type.
        RuntimeTypeHandle myRTHFromType = typeof(MyClass1).TypeHandle;

        Console.WriteLine("\nmyRTHFromObject.Value:  {0}", myRTHFromObject.Value);
        Console.WriteLine("myRTHFromObject.GetType():  {0}", myRTHFromObject.GetType());
        Console.WriteLine("Get the type back from the handle...");
        Console.WriteLine("Type.GetTypeFromHandle(myRTHFromObject):  {0}",
            Type.GetTypeFromHandle(myRTHFromObject));

        Console.WriteLine("\nmyRTHFromObject.Equals(myRTHFromType):  {0}",
            myRTHFromObject.Equals(myRTHFromType));

        Console.WriteLine("\nmyRTHFromType.Value:  {0}", myRTHFromType.Value);
        Console.WriteLine("myRTHFromType.GetType():  {0}", myRTHFromType.GetType());
        Console.WriteLine("Get the type back from the handle...");
        Console.WriteLine("Type.GetTypeFromHandle(myRTHFromType):  {0}",
            Type.GetTypeFromHandle(myRTHFromType));
    }
}

/* This code example produces output similar to the following:

myRTHFromObject.Value:  799464
myRTHFromObject.GetType():  System.RuntimeTypeHandle
Get the type back from the handle...
Type.GetTypeFromHandle(myRTHFromObject):  MyClass1

myRTHFromObject.Equals(myRTHFromType):  True

myRTHFromType.Value:  799464
myRTHFromType.GetType():  System.RuntimeTypeHandle
Get the type back from the handle...
Type.GetTypeFromHandle(myRTHFromType):  MyClass1
 */

open System

type MyClass1() =
    let x = 0
    member _.MyMethod() =
        x

let myClass1 = MyClass1()

// Get the RuntimeTypeHandle from an object.
let myRTHFromObject = Type.GetTypeHandle myClass1
// Get the RuntimeTypeHandle from a type.
let myRTHFromType = typeof<MyClass1>.TypeHandle

printfn $"\nmyRTHFromObject.Value:  {myRTHFromObject.Value}"
printfn $"myRTHFromObject.GetType():  {myRTHFromObject.GetType()}"
printfn "Get the type back from the handle..."
printfn $"Type.GetTypeFromHandle(myRTHFromObject):  {Type.GetTypeFromHandle myRTHFromObject}"

printfn $"\nmyRTHFromObject.Equals(myRTHFromType):  {myRTHFromObject.Equals myRTHFromType}"

printfn $"\nmyRTHFromType.Value:  {myRTHFromType.Value}"
printfn $"myRTHFromType.GetType():  {myRTHFromType.GetType()}"
printfn "Get the type back from the handle..."
printfn $"Type.GetTypeFromHandle(myRTHFromType):  {Type.GetTypeFromHandle myRTHFromType}"

// This code example produces output similar to the following:
//     myRTHFromObject.Value:  799464
//     myRTHFromObject.GetType():  System.RuntimeTypeHandle
//     Get the type back from the handle...
//     Type.GetTypeFromHandle(myRTHFromObject):  MyClass1
//    
//     myRTHFromObject.Equals(myRTHFromType):  True
//    
//     myRTHFromType.Value:  799464
//     myRTHFromType.GetType():  System.RuntimeTypeHandle
//     Get the type back from the handle...
//     Type.GetTypeFromHandle(myRTHFromType):  MyClass1

Imports System.Reflection

Public Class MyClass1
    Private x As Integer = 0
   
    Public Function MyMethod() As Integer
        Return x
    End Function 'MyMethod
End Class 

Public Class MyClass2
   
    Public Shared Sub Main()
        Dim myClass1 As New MyClass1()
      
        ' Get the RuntimeTypeHandle from an object.
        Dim myRTHFromObject As RuntimeTypeHandle = Type.GetTypeHandle(myClass1)
        ' Get the RuntimeTypeHandle from a type.
        Dim myRTHFromType As RuntimeTypeHandle = GetType(MyClass1).TypeHandle
      
        Console.WriteLine(vbLf & "myRTHFromObject.Value:  {0}", _
            myRTHFromObject.Value)
        Console.WriteLine("myRTHFromObject.GetType():  {0}", _
            myRTHFromObject.GetType())
        Console.WriteLine("Get the type back from the handle...")
        Console.WriteLine("Type.GetTypeFromHandle(myRTHFromObject):  {0}", _
            Type.GetTypeFromHandle(myRTHFromObject))

        Console.WriteLine(vbLf & "myRTHFromObject.Equals(myRTHFromType):  {0}", _
            myRTHFromObject.Equals(myRTHFromType))

        Console.WriteLine(vbLf & "myRTHFromType.Value:  {0}", _
            myRTHFromType.Value)
        Console.WriteLine("myRTHFromType.GetType():  {0}", _
            myRTHFromType.GetType())
        Console.WriteLine("Get the type back from the handle...")
        Console.WriteLine("Type.GetTypeFromHandle(myRTHFromType):  {0}", _
            Type.GetTypeFromHandle(myRTHFromType))
    End Sub 
End Class 

' This code example produces output similar to the following:
'
'myRTHFromObject.Value:  7549720
'myRTHFromObject.GetType():  System.RuntimeTypeHandle
'Get the type back from the handle...
'Type.GetTypeFromHandle(myRTHFromObject):  MyClass1
'
'myRTHFromObject.Equals(myRTHFromType):  True
'
'myRTHFromType.Value:  7549720
'myRTHFromType.GetType():  System.RuntimeTypeHandle
'Get the type back from the handle...
'Type.GetTypeFromHandle(myRTHFromType):  MyClass1

Propriedades

Value

Obtém um identificador para o tipo representado por esta instância.

Métodos

Equals(Object)	Indica se o objeto especificado é igual à estrutura RuntimeTypeHandle atual.
Equals(RuntimeTypeHandle)	Indica se a estrutura RuntimeTypeHandle especificada é igual à estrutura RuntimeTypeHandle atual.
FromIntPtr(IntPtr)	Retorna um novo RuntimeTypeHandle objeto criado de um identificador para um RuntimeType.
GetHashCode()	Retorna o código hash para a instância atual.
GetModuleHandle()	Obtém um identificador para o módulo que contém o tipo representado pela instância atual.
GetObjectData(SerializationInfo, StreamingContext)	Popula uma SerializationInfo com os dados necessários para desserializar o tipo representado pela instância atual.
ToIntPtr(RuntimeTypeHandle)	Retorna a representação de ponteiro interno de um RuntimeTypeHandle objeto.

Operadores

Equality(Object, RuntimeTypeHandle)	Indica se um objeto e uma estrutura RuntimeTypeHandle são iguais.
Equality(RuntimeTypeHandle, Object)	Indica se uma estrutura RuntimeTypeHandle é igual a um objeto.
Inequality(Object, RuntimeTypeHandle)	Indica se um objeto e uma estrutura RuntimeTypeHandle não são iguais.
Inequality(RuntimeTypeHandle, Object)	Indica se uma estrutura RuntimeTypeHandle não é igual a um objeto.

Aplica-se a

Compartilhar via