FieldInfo.GetFieldFromHandle Método

Definição

Namespace:

System.Reflection

Assembly:

System.Runtime.dll

Obtém um FieldInfo para o campo representado por um identificador.

Sobrecargas

GetFieldFromHandle(RuntimeFieldHandle)	Obtém um FieldInfo para o campo representado pelo identificador especificado.
GetFieldFromHandle(RuntimeFieldHandle, RuntimeTypeHandle)	Obtém um FieldInfo para campo representado pelo identificador especificado, para o tipo genérico especificado.

GetFieldFromHandle(RuntimeFieldHandle)

Origem:

FieldInfo.CoreCLR.cs

Obtém um FieldInfo para o campo representado pelo identificador especificado.

public:
 static System::Reflection::FieldInfo ^ GetFieldFromHandle(RuntimeFieldHandle handle);

public static System.Reflection.FieldInfo GetFieldFromHandle (RuntimeFieldHandle handle);

static member GetFieldFromHandle : RuntimeFieldHandle -> System.Reflection.FieldInfo

Public Shared Function GetFieldFromHandle (handle As RuntimeFieldHandle) As FieldInfo

Parâmetros

handle

RuntimeFieldHandle

Uma estrutura RuntimeFieldHandle que contém o identificador para a representação interna de metadados de um campo.

Retornos

FieldInfo

Um objeto FieldInfo que representa o campo especificado por handle.

Exceções

ArgumentException

handle é inválido.

Exemplos

O exemplo de código a seguir usa o Type.GetFields método para obter FieldInfo objetos para os campos de um tipo, obtém uma RuntimeFieldHandle estrutura para cada campo e recupera os FieldInfo objetos dos identificadores usando essa sobrecarga do GetFieldFromHandle método.

using namespace System;
using namespace System::Reflection;

public ref class FieldInfo_GetFieldFromHandle
{
public:
   String^ x;
   Char y;
   float a;
   int b;
};

int main()
{
   // Get the type of the FieldInfo_GetFieldFromHandle class.
   Type^ myType = FieldInfo_GetFieldFromHandle::typeid;

   // Get the fields of the FieldInfo_GetFieldFromHandle class.
   array<FieldInfo^>^myFieldInfoArray = myType->GetFields();
   Console::WriteLine( "\nThe field information of the declared  fields x, y, a, and b is:\n" );
   RuntimeFieldHandle myRuntimeFieldHandle;
   for ( int i = 0; i < myFieldInfoArray->Length; i++ )
   {
      // Get the RuntimeFieldHandle of myFieldInfoArray.
      myRuntimeFieldHandle = myFieldInfoArray[ i ]->FieldHandle;

      // Call the GetFieldFromHandle method. 
      FieldInfo^ myFieldInfo = FieldInfo::GetFieldFromHandle( myRuntimeFieldHandle );

      // Display the FieldInfo of myFieldInfo.
      Console::WriteLine( " {0}", myFieldInfo );
   }
}

using System;
using System.Reflection;

public class FieldInfo_GetFieldFromHandle
{
    public string x;
    public char y;
    public float a;
    public int b;

    public static void Main()
    {
        // Get the type of the FieldInfo_GetFieldFromHandle class.
        Type myType = typeof(FieldInfo_GetFieldFromHandle);
        // Get the fields of the FieldInfo_GetFieldFromHandle class.
        FieldInfo [] myFieldInfoArray = myType.GetFields();
        Console.WriteLine("\nThe field information of the declared" +
            " fields x, y, a, and b is:\n");
        RuntimeFieldHandle myRuntimeFieldHandle;
        for(int i = 0; i < myFieldInfoArray.Length; i++)
        {
            // Get the RuntimeFieldHandle of myFieldInfoArray.
            myRuntimeFieldHandle = myFieldInfoArray[i].FieldHandle;
            // Call the GetFieldFromHandle method.
            FieldInfo myFieldInfo = FieldInfo.GetFieldFromHandle(myRuntimeFieldHandle);
            // Display the FieldInfo of myFieldInfo.
            Console.WriteLine("{0}", myFieldInfo);
        }
    }
}

Imports System.Reflection

Public Class FieldInfo_GetFieldFromHandle
    Public x As String
    Public y As Char
    Public a As Single
    Public b As Integer

    Public Shared Sub Main()
        ' Get the type of the FieldInfo_GetFieldFromHandle class.
        Dim myType As Type = GetType(FieldInfo_GetFieldFromHandle)
        ' Get the fields of the FieldInfo_GetFieldFromHandle class.
        Dim myFieldInfoArray As FieldInfo() = myType.GetFields()
        Console.WriteLine(ControlChars.NewLine & _
           "The field information of the declared" & _
           " fields x, y, a, and b is:" & ControlChars.NewLine)
        Dim myRuntimeFieldHandle As RuntimeFieldHandle
        Dim i As Integer
        For i = 0 To myFieldInfoArray.Length - 1
            ' Get the RuntimeFieldHandle of myFieldInfoArray.
            myRuntimeFieldHandle = myFieldInfoArray(i).FieldHandle
            ' Call the GetFieldFromHandle method. 
            Dim myFieldInfo As FieldInfo = FieldInfo.GetFieldFromHandle(myRuntimeFieldHandle)
            ' Display the FieldInfo of myFieldInfo.
            Console.WriteLine("{0}", myFieldInfo)
        Next i
    End Sub
End Class

Comentários

Os identificadores são válidos somente no domínio do aplicativo no qual foram obtidos.

GetFieldFromHandle(RuntimeFieldHandle, RuntimeTypeHandle)

Origem:

FieldInfo.CoreCLR.cs

Obtém um FieldInfo para campo representado pelo identificador especificado, para o tipo genérico especificado.

public:
 static System::Reflection::FieldInfo ^ GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType);

public static System.Reflection.FieldInfo GetFieldFromHandle (RuntimeFieldHandle handle, RuntimeTypeHandle declaringType);

static member GetFieldFromHandle : RuntimeFieldHandle * RuntimeTypeHandle -> System.Reflection.FieldInfo

Public Shared Function GetFieldFromHandle (handle As RuntimeFieldHandle, declaringType As RuntimeTypeHandle) As FieldInfo

Parâmetros

handle

RuntimeFieldHandle

Uma estrutura RuntimeFieldHandle que contém o identificador para a representação interna de metadados de um campo.

declaringType

RuntimeTypeHandle

Uma estrutura RuntimeTypeHandle que contém o identificador para o tipo genérico que define o campo.

Retornos

FieldInfo

Um objeto FieldInfo que representa o campo especificado por handle, no tipo genérico especificado por declaringType.

Exceções

ArgumentException

handle é inválido.

- ou -

declaringType não é compatível com handle. Por exemplo, declaringType é o identificador de tipo de runtime da definição de tipo genérico, enquanto handle vem de um tipo construído.

Exemplos

O exemplo a seguir mostra como recuperar FieldInfo objetos para campos em classes genéricas construídas. O exemplo define o tipo Test<T> genérico (Test(Of T) no Visual Basic) com um único campo chamado TestField, do tipo T. O exemplo obtém o RuntimeFieldHandle e RuntimeTypeHandle para o caso em que T é Stringe demonstra o seguinte:

• Uma exceção será gerada se a sobrecarga do GetFieldFromHandle(RuntimeFieldHandle) método for usada. Isso é verdadeiro mesmo se o campo não for do tipo T.

• Um FieldInfo será recuperado com êxito se o identificador de tipo de runtime for da mesma construção que o identificador de campo de runtime, nesse caso Test<string>.

• Se o identificador de tipo de runtime for de uma construção compatível, nesse caso Test<object>, um FieldInfo para o campo na construção compatível será recuperado.

• Se o identificador de tipo de runtime não for de uma construção compatível, uma exceção será gerada. Nesse caso, um tipo de valor é especificado para T.

using System;
using System.Reflection;

// A generic class with a field whose type is specified by the
// generic type parameter of the class.
public class Test<T>
{
    public T TestField;
}

public class Example
{
    public static void Main()
    {
        // Get type handles for Test<String> and its field.
        RuntimeTypeHandle rth = typeof(Test<string>).TypeHandle;
        RuntimeFieldHandle rfh = typeof(Test<string>).GetField("TestField").FieldHandle;

        // When a field belongs to a constructed generic type,
        // such as Test<String>, retrieving the field from the
        // field handle requires the type handle of the constructed
        // generic type. An exception is thrown if the type is not
        // included.
        try
        {
            FieldInfo f1 = FieldInfo.GetFieldFromHandle(rfh);
        }
        catch(Exception ex)
        {
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message);
        }

        // To get the FieldInfo for a field on a generic type, use the
        // overload that specifies the type handle.
        FieldInfo fi = FieldInfo.GetFieldFromHandle(rfh, rth);
        Console.WriteLine("\r\nThe type of {0} is: {1}", fi.Name, fi.FieldType);

        // All constructions of Test<T> for which T is a reference
        // type share the same implementation, so the same runtime
        // field handle can be used to retrieve the FieldInfo for
        // TestField on any such construction. Here the runtime field
        // handle is used with Test<Object>.
        fi = FieldInfo.GetFieldFromHandle(rfh, typeof(Test<object>).TypeHandle);
        Console.WriteLine("\r\nThe type of {0} is: {1}", fi.Name, fi.FieldType);

        // Each construction of Test<T> for which T is a value type
        // has its own unique implementation, and an exception is thrown
        // if you supply a constructed type other than the one that
        // the runtime field handle belongs to.
        try
        {
            fi = FieldInfo.GetFieldFromHandle(rfh, typeof(Test<int>).TypeHandle);
        }
        catch(Exception ex)
        {
            Console.WriteLine("\r\n{0}: {1}", ex.GetType().Name, ex.Message);
        }
    }
}

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

ArgumentException: Cannot resolve field TestField because the declaring type of
the field handle Test`1[T] is generic. Explicitly provide the declaring type to
GetFieldFromHandle.

The type of TestField is: System.String

The type of TestField is: System.Object

ArgumentException: Type handle 'Test`1[System.Int32]' and field handle with decl
aring type 'Test`1[System.__Canon]' are incompatible. Get RuntimeFieldHandle and
 declaring RuntimeTypeHandle off the same FieldInfo.
 */

Imports System.Reflection

' A generic class with a field whose type is specified by the 
' generic type parameter of the class.
Public Class Test(Of T)
    Public TestField As T 
End Class

Public Class Example

    Public Shared Sub Main()

        ' Get type handles for Test(Of String) and its field.
        Dim rth As RuntimeTypeHandle = _
            GetType(Test(Of String)).TypeHandle
        Dim rfh As RuntimeFieldHandle = _
            GetType(Test(Of String)).GetField("TestField").FieldHandle

        ' When a field belongs to a constructed generic type, 
        ' such as Test(Of String), retrieving the field from the
        ' field handle requires the type handle of the constructed
        ' generic type. An exception is thrown if the type is not
        ' included.
        Try
            Dim f1 As FieldInfo = FieldInfo.GetFieldFromHandle(rfh)
        Catch ex As Exception
            Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message)
        End Try

        ' To get the FieldInfo for a field on a generic type, use the
        ' overload that specifies the type handle.
        Dim fi As FieldInfo = FieldInfo.GetFieldFromHandle(rfh, rth)
        Console.WriteLine(vbCrLf & "The type of {0} is: {1}", _
            fi.Name, fi.FieldType)

        ' All constructions of Test(Of T) for which T is a reference
        ' type share the same implementation, so the same runtime 
        ' field handle can be used to retrieve the FieldInfo for 
        ' TestField on any such construction. Here the runtime field
        ' handle is used with Test(Of Object).
        fi = FieldInfo.GetFieldFromHandle(rfh, _
                               GetType(Test(Of Object)).TypeHandle)
        Console.WriteLine(vbCrLf & "The type of {0} is: {1}", _
            fi.Name, fi.FieldType)

        ' Each construction of Test(Of T) for which T is a value type
        ' has its own unique implementation, and an exception is thrown
        ' if you supply a constructed type other than the one that 
        ' the runtime field handle belongs to.  
        Try
            fi = FieldInfo.GetFieldFromHandle(rfh, _
                               GetType(Test(Of Integer)).TypeHandle)
        Catch ex As Exception
            Console.WriteLine(vbCrLf & "{0}: {1}", ex.GetType().Name, ex.Message)
        End Try

    End Sub
End Class

' This code example produces output similar to the following:
'
'ArgumentException: Cannot resolve field TestField because the declaring type of
'the field handle Test`1[T] is generic. Explicitly provide the declaring type to
'GetFieldFromHandle.
'
'The type of TestField is: System.String
'
'The type of TestField is: System.Object
'
'ArgumentException: Type handle 'Test`1[System.Int32]' and field handle with decl
'aring type 'Test`1[System.__Canon]' are incompatible. Get RuntimeFieldHandle and
' declaring RuntimeTypeHandle off the same FieldInfo.

Comentários

Os identificadores são válidos somente no domínio do aplicativo no qual foram obtidos.

A prática recomendada é que declaringType deve ser sempre o identificador de tipo de runtime do tipo construído ao qual handle pertence. Ou seja, se handle for um identificador de campo de runtime para um campo ao qual pertence MyType<int> (MyType(Of Integer) no Visual Basic), declaringType será o identificador de tipo de runtime para MyType<int>. Não use o identificador de tipo de runtime da definição de tipo genérico, a menos que o identificador de campo de runtime represente um campo na definição de tipo genérico.

As implementações são compatíveis em alguns casos. Por exemplo, uma única implementação é compartilhada por todos os tipos construídos a partir de uma definição de tipo genérico específica usando tipos de referência para os argumentos de tipo genérico. Por exemplo, MyType<string>, MyType<object>e MyType<ArrayList> todos compartilham a mesma implementação. Nessa situação, o FieldInfo objeto retornado representa um campo no tipo que declaringType especifica, independentemente da origem original de handle. Essa prática não é recomendada, pois funciona somente se os argumentos de tipo genérico do tipo construído forem tipos de referência.

Se um argumento genérico for um tipo de valor, o identificador de tipo de runtime do tipo construído não será compatível com identificadores de campo de runtime de construções que tenham um tipo de referência na mesma posição de parâmetro genérico ou que tenham um tipo de valor diferente nessa posição. Nesse caso, a única maneira de usar a FieldInfo.GetFieldFromHandle(RuntimeFieldHandle, RuntimeTypeHandle) sobrecarga é garantir que declaringType seja o identificador de tipo de runtime para o tipo construído ao qual handle pertence.