FieldInfo.GetFieldFromHandle Methode

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

Parameters

Retouren

Een FieldInfo object dat het veld vertegenwoordigt dat is opgegeven door handle.

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld wordt de Type.GetFields methode gebruikt om objecten op te halen FieldInfo voor de velden van een type, wordt een RuntimeFieldHandle structuur voor elk veld opgehaald en worden vervolgens de FieldInfo objecten opgehaald uit de ingangen met behulp van deze overbelasting van de GetFieldFromHandle methode.

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

Opmerkingen

Ingangen zijn alleen geldig in het toepassingsdomein waarin ze zijn verkregen.

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

Parameters

Retouren

Een FieldInfo object dat het veld vertegenwoordigt dat is opgegeven door handle, in het algemene type dat is opgegeven door declaringType.

Kenmerken

ComVisibleAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u hoe u objecten ophaalt FieldInfo voor velden in samengestelde algemene klassen. In het voorbeeld wordt het algemene type Test<T> (Test(Of T) in Visual Basic) gedefinieerd met één veld met de naam TestField, van het type T. In het voorbeeld wordt de RuntimeFieldHandle en RuntimeTypeHandle voor de situatie weergegevenStringT, en wordt het volgende gedemonstreert:

• Er wordt een uitzondering gegenereerd als de overbelasting van de GetFieldFromHandle(RuntimeFieldHandle) methode wordt gebruikt. Dit is waar, zelfs als het veld niet van het type Tis.

• Een FieldInfo wordt opgehaald als de runtime-typegreep afkomstig is van dezelfde constructie als de runtime-veldgreep, in dit geval Test<string>.

• Als de runtimetypegreep afkomstig is van een compatibele constructie, wordt in dit geval Test<object>een FieldInfo voor het veld op de compatibele constructie opgehaald.

• Als de runtimetypegreep niet afkomstig is van een compatibele constructie, wordt er een uitzondering gegenereerd. In dit geval wordt een waardetype opgegeven voor 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.

Opmerkingen

Ingangen zijn alleen geldig in het toepassingsdomein waarin ze zijn verkregen.

De aanbevolen procedure is dat declaringType dit altijd de runtime-typegreep moet zijn van het samengestelde type waartoe handle het behoort. Als handle een runtime-veldingang is voor een veld dat deel uitmaakt van MyType<int> (MyType(Of Integer) in Visual Basic), is declaringType de runtime-typegreep voor MyType<int>. Gebruik de runtime-typegreep van de algemene typedefinitie niet, tenzij de runtimeveldgreep een veld in de algemene typedefinitie vertegenwoordigt.

Implementaties zijn in sommige gevallen compatibel. Eén implementatie wordt bijvoorbeeld gedeeld door alle typen die zijn samengesteld op basis van een bepaalde algemene typedefinitie met behulp van referentietypen voor de algemene typeargumenten. Bijvoorbeeld, MyType<string>MyType<object>en MyType<ArrayList> allemaal dezelfde implementatie delen. In deze situatie vertegenwoordigt het FieldInfo object dat wordt geretourneerd een veld voor het type dat declaringType aangeeft, ongeacht de oorspronkelijke bron van handle. Deze procedure wordt niet aanbevolen, omdat dit alleen werkt als de algemene typeargumenten van het samengestelde type verwijzingstypen zijn.

Als een algemeen argument een waardetype is, is de runtime-typegreep van het samengestelde type niet compatibel met runtime-veldgrepen van constructies met een verwijzingstype in dezelfde algemene parameterpositie, of die een ander waardetype in die positie hebben. In dat geval is de enige manier om de FieldInfo.GetFieldFromHandle(RuntimeFieldHandle, RuntimeTypeHandle) overbelasting te gebruiken ervoor te zorgen dat declaringType de runtime-typehandgreep is voor het samengestelde type waartoe handle het behoort.