Partager via


FieldInfo.GetFieldFromHandle Méthode

Définition

Obtient FieldInfo pour le champ représenté par un handle.

Surcharges

GetFieldFromHandle(RuntimeFieldHandle)

Obtient FieldInfo pour le champ représenté par le handle spécifié.

GetFieldFromHandle(RuntimeFieldHandle, RuntimeTypeHandle)

Obtient FieldInfo pour le champ représenté par le handle spécifié, pour le type générique donné.

GetFieldFromHandle(RuntimeFieldHandle)

Source:
FieldInfo.CoreCLR.cs
Source:
FieldInfo.CoreCLR.cs
Source:
FieldInfo.CoreCLR.cs

Obtient FieldInfo pour le champ représenté par le handle spécifié.

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

Paramètres

handle
RuntimeFieldHandle

Structure RuntimeFieldHandle qui contient le handle vers la représentation interne des métadonnées d'un champ.

Retours

Objet FieldInfo représentant le champ spécifié par handle.

Exceptions

handle n'est pas valide.

Exemples

L’exemple de code suivant utilise la Type.GetFields méthode pour obtenir FieldInfo des objets pour les champs d’un type, obtient une RuntimeFieldHandle structure pour chaque champ, puis récupère les FieldInfo objets des handles à l’aide de cette surcharge de la GetFieldFromHandle méthode.

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

Remarques

Les descripteurs sont valides uniquement dans le domaine d’application dans lequel ils ont été obtenus.

S’applique à

GetFieldFromHandle(RuntimeFieldHandle, RuntimeTypeHandle)

Source:
FieldInfo.CoreCLR.cs
Source:
FieldInfo.CoreCLR.cs
Source:
FieldInfo.CoreCLR.cs

Obtient FieldInfo pour le champ représenté par le handle spécifié, pour le type générique donné.

public:
 static System::Reflection::FieldInfo ^ GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType);
public static System.Reflection.FieldInfo GetFieldFromHandle (RuntimeFieldHandle handle, RuntimeTypeHandle declaringType);
[System.Runtime.InteropServices.ComVisible(false)]
public static System.Reflection.FieldInfo GetFieldFromHandle (RuntimeFieldHandle handle, RuntimeTypeHandle declaringType);
static member GetFieldFromHandle : RuntimeFieldHandle * RuntimeTypeHandle -> System.Reflection.FieldInfo
[<System.Runtime.InteropServices.ComVisible(false)>]
static member GetFieldFromHandle : RuntimeFieldHandle * RuntimeTypeHandle -> System.Reflection.FieldInfo
Public Shared Function GetFieldFromHandle (handle As RuntimeFieldHandle, declaringType As RuntimeTypeHandle) As FieldInfo

Paramètres

handle
RuntimeFieldHandle

Structure RuntimeFieldHandle qui contient le handle vers la représentation interne des métadonnées d'un champ.

declaringType
RuntimeTypeHandle

Structure RuntimeTypeHandle contenant le handle vers le type générique qui définit le champ.

Retours

Objet FieldInfo représentant le champ spécifié par handle dans le type générique spécifié par declaringType.

Attributs

Exceptions

handle n'est pas valide.

- ou -

declaringType n'est pas compatible avec handle. Par exemple, declaringType est le handle de type runtime de la définition de type générique, et handle vient d'un type construit.

Exemples

L’exemple suivant montre comment récupérer des FieldInfo objets pour des champs sur des classes génériques construites. L’exemple définit le type Test<T> générique (Test(Of T) en Visual Basic) avec un seul champ nommé TestField, de type T. L’exemple obtient le RuntimeFieldHandle et RuntimeTypeHandle pour le cas où T est String, et illustre les éléments suivants :

  • Une exception est levée si la surcharge de méthode GetFieldFromHandle(RuntimeFieldHandle) est utilisée. Cela est vrai même si le champ n’est pas de type T.

  • Un FieldInfo est récupéré correctement si le handle de type runtime provient de la même construction que le handle de champ runtime, dans ce cas Test<string>.

  • Si le handle de type runtime provient d’une construction compatible, dans ce cas Test<object>, un FieldInfo pour le champ sur la construction compatible est récupéré.

  • Si le handle de type runtime ne provient pas d’une construction compatible, une exception est levée. Dans ce cas, un type valeur est spécifié pour 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.

Remarques

Les descripteurs sont valides uniquement dans le domaine d’application dans lequel ils ont été obtenus.

La pratique recommandée est que doit declaringType toujours être le handle de type runtime du type construit auquel handle appartient. Autrement dit, si handle est un handle de champ d’exécution pour un champ qui appartient à MyType<int> (MyType(Of Integer) en Visual Basic), declaringType est le handle de type runtime pour MyType<int>. N’utilisez pas le handle de type runtime de la définition de type générique, sauf si le handle de champ d’exécution représente un champ sur la définition de type générique.

Les implémentations sont compatibles dans certains cas. Par exemple, une implémentation unique est partagée par tous les types construits à partir d’une définition de type générique particulière à l’aide de types référence pour les arguments de type générique. Par exemple, MyType<string>, MyType<object>et MyType<ArrayList> partagent tous la même implémentation. Dans ce cas, l’objet FieldInfo retourné représente un champ sur le type qui declaringType spécifie, quelle que soit la source d’origine de handle. Cette pratique n’est pas recommandée, car elle fonctionne uniquement si les arguments de type générique du type construit sont des types référence.

Si un argument générique est un type valeur, le handle de type runtime du type construit n’est pas compatible avec les handles de champ d’exécution des constructions qui ont un type référence dans la même position de paramètre générique, ou qui ont un type valeur différent dans cette position. Dans ce cas, la seule façon d’utiliser la FieldInfo.GetFieldFromHandle(RuntimeFieldHandle, RuntimeTypeHandle) surcharge consiste à s’assurer que declaringType est le handle de type runtime pour le type construit qui handle appartient à.

S’applique à