Freigeben über


TypeBuilder.GetField Methode

Definition

Gibt ein Feld zurück, das durch den aktuellen TypeBuilder definiert ist.

Überlädt

GetField(Type, FieldInfo)

Gibt das Feld des angegebenen konstruierten generischen Typs zurück, der dem angegebenen Feld der generischen Typdefinition entspricht.

GetField(String, BindingFlags)

Gibt das vom angegebenen Namen angegebene Feld zurück.

GetField(Type, FieldInfo)

Quelle:
TypeBuilder.cs
Quelle:
RuntimeTypeBuilder.cs
Quelle:
TypeBuilder.cs

Gibt das Feld des angegebenen konstruierten generischen Typs zurück, der dem angegebenen Feld der generischen Typdefinition entspricht.

public:
 static System::Reflection::FieldInfo ^ GetField(Type ^ type, System::Reflection::FieldInfo ^ field);
public static System.Reflection.FieldInfo GetField (Type type, System.Reflection.FieldInfo field);
static member GetField : Type * System.Reflection.FieldInfo -> System.Reflection.FieldInfo
Public Shared Function GetField (type As Type, field As FieldInfo) As FieldInfo

Parameter

type
Type

Der konstruierte generische Typ, dessen Feld zurückgegeben wird.

field
FieldInfo

Ein Feld zur generischen Typdefinition von type, das angibt, welches Feld von type zurückgegeben werden muss.

Gibt zurück

Ein FieldInfo-Objekt, das das Feld von type darstellt, das field entspricht, welches ein Feld angibt, das zur generischen Typdefinition von type gehört.

Ausnahmen

type stellt keinen generischen Typ dar.

- oder -

type ist nicht vom Typ TypeBuilder.

- oder -

Der deklarierende Typ von field ist keine generische Typdefinition.

- oder -

Der deklarierende Typ von field ist nicht die generische Typdefinition von type.

Beispiele

Das folgende Codebeispiel enthält Quellcode für eine generische Klasse mit dem Namen Sample, die über einen Typparameter namens verfügt T. Die -Klasse verfügt über ein Feld mit dem Namen Field, vom Typ Tund eine generische Methode mit dem Namen GM ihres eigenen Typparameters namens U. Die -Methode GM erstellt eine instance von Sample, indem sie ihren eigenen Typparameter U durch den Typparameter von Sampleersetzt, und speichert ihren Eingabeparameter in Field. Dieser Quellcode wird kompiliert, aber nicht verwendet. Sie können es mit dem Ildasm.exe (IL Disassembler) anzeigen und mit dem von der -Klasse Exampleausgegebenen Code vergleichen.

Der Code in der -Klasse Example veranschaulicht die Verwendung der GetField -Methode zum Ausgeben von generischem Code. Die Main -Methode der -Klasse Example erstellt eine dynamische Assembly, die eine Klasse mit dem Namen Sampleenthält, und verwendet die DefineGenericParameters -Methode, um sie generisch zu machen, indem sie einen Typparameter namens Thinzufügt. Ein parameterloser Konstruktor und ein Feld mit dem Namen Field, vom Typ T, werden der Klasse Samplehinzugefügt. Mithilfe der MethodBuilder.DefineGenericParameters -Methode wird eine Methode GM hinzugefügt und in eine generische Methode umgewandelt. Der Type-Parameter von GM heißt U. Nachdem der Type-Parameter definiert wurde, wird die Signatur von GM mithilfe der MethodBuilder.SetSignature -Methode hinzugefügt. Es gibt keinen Rückgabetyp und keine erforderlichen oder benutzerdefinierten Modifizierer. Daher sind null alle Parameter dieser Methode außer parameterTypes; parameterTypes legt den Typ des einzigen Parameters der Methode auf Ufest, den generischen Typparameter der Methode. Der Text der -Methode erstellt eine instance des konstruierten Typs Sample<U> (Sample(Of U) in Visual Basic), weist den -Parameter der Methode zu Fieldund gibt dann den Wert von ausField. Die GetField -Methode wird verwendet, um ein FieldInfo zu erstellen, das das Feld des erstellten generischen Typs Sample<U> in den OpCodes.Stfld Anweisungen und OpCodes.Ldfld darstellt.

Ein Dummytyp ist definiert, um die Einstiegspunktmethode Mainzu enthalten. Im Textkörper von Mainwird die statische GM Methode für den erstellten generischen Typ Sample<int> (Sample(Of Integer) in Visual Basic) aufgerufen, wobei der Typ String durch Uersetzt wird.

Wenn das Codebeispiel ausgeführt wird, wird die ausgegebene Assembly als TypeBuilderGetFieldExample.exe gespeichert. Sie können TypeBuilderGetFieldExample.exe ausführen, und Sie können den Ildasm.exe (IL Disassembler) verwenden, um den ausgegebenen Code mit dem Code für die Klasse zu vergleichen, die Sample in das Codebeispiel selbst kompiliert wird.

using System;
using System.Reflection;
using System.Reflection.Emit;

// Compare the MSIL in this class to the MSIL
// generated by the Reflection.Emit code in class
// Example.
public class Sample<T>
{
  public T Field;
  public static void GM<U>(U val)
  {
    Sample<U> s = new Sample<U>();
    s.Field = val;
    Console.WriteLine(s.Field);
  }
}

public class Example
{
    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName =
            new AssemblyName("TypeBuilderGetFieldExample");
        AssemblyBuilder myAssembly = myDomain.DefineDynamicAssembly(
            myAsmName, AssemblyBuilderAccess.Save);
        ModuleBuilder myModule = myAssembly.DefineDynamicModule(
            myAsmName.Name,
            myAsmName.Name + ".exe");

        // Define the sample type.
        TypeBuilder myType = myModule.DefineType("Sample",
            TypeAttributes.Class | TypeAttributes.Public);

        // Add a type parameter, making the type generic.
        string[] typeParamNames = {"T"};
        GenericTypeParameterBuilder[] typeParams =
            myType.DefineGenericParameters(typeParamNames);

        // Define a default constructor. Normally it would
        // not be necessary to define the default constructor,
        // but in this case it is needed for the call to
        // TypeBuilder.GetConstructor, which gets the default
        // constructor for the generic type constructed from
        // Sample<T>, in the generic method GM<U>.
        ConstructorBuilder ctor = myType.DefineDefaultConstructor(
            MethodAttributes.PrivateScope | MethodAttributes.Public |
            MethodAttributes.HideBySig | MethodAttributes.SpecialName |
            MethodAttributes.RTSpecialName);

        // Add a field of type T, with the name Field.
        FieldBuilder myField = myType.DefineField("Field",
            typeParams[0],
            FieldAttributes.Public);

        // Add a method and make it generic, with a type
        // parameter named U. Note how similar this is to
        // the way Sample is turned into a generic type. The
        // method has no signature, because the type of its
        // only parameter is U, which is not yet defined.
        MethodBuilder genMethod = myType.DefineMethod("GM",
            MethodAttributes.Public | MethodAttributes.Static);
        string[] methodParamNames = {"U"};
        GenericTypeParameterBuilder[] methodParams =
            genMethod.DefineGenericParameters(methodParamNames);

        // Now add a signature for genMethod, specifying U
        // as the type of the parameter. There is no return value
        // and no custom modifiers.
        genMethod.SetSignature(null, null, null,
            new Type[] { methodParams[0] }, null, null);

        // Emit a method body for the generic method.
        ILGenerator ilg = genMethod.GetILGenerator();
        // Construct the type Sample<U> using MakeGenericType.
        Type SampleOfU = myType.MakeGenericType( methodParams[0] );
        // Create a local variable to store the instance of
        // Sample<U>.
        ilg.DeclareLocal(SampleOfU);
        // Call the default constructor. Note that it is
        // necessary to have the default constructor for the
        // constructed generic type Sample<U>; use the
        // TypeBuilder.GetConstructor method to obtain this
        // constructor.
        ConstructorInfo ctorOfU = TypeBuilder.GetConstructor(
            SampleOfU, ctor);
        ilg.Emit(OpCodes.Newobj, ctorOfU);
        // Store the instance in the local variable; load it
        // again, and load the parameter of genMethod.
        ilg.Emit(OpCodes.Stloc_0);
        ilg.Emit(OpCodes.Ldloc_0);
        ilg.Emit(OpCodes.Ldarg_0);
        // In order to store the value in the field of the
        // instance of Sample<U>, it is necessary to have
        // a FieldInfo representing the field of the
        // constructed type. Use TypeBuilder.GetField to
        // obtain this FieldInfo.
        FieldInfo FieldOfU = TypeBuilder.GetField(
            SampleOfU, myField);
        // Store the value in the field.
        ilg.Emit(OpCodes.Stfld, FieldOfU);
        // Load the instance, load the field value, box it
        // (specifying the type of the type parameter, U), and
        // print it.
        ilg.Emit(OpCodes.Ldloc_0);
        ilg.Emit(OpCodes.Ldfld, FieldOfU);
        ilg.Emit(OpCodes.Box, methodParams[0]);
        MethodInfo writeLineObj =
            typeof(Console).GetMethod("WriteLine",
                new Type[] { typeof(object) });
        ilg.EmitCall(OpCodes.Call, writeLineObj, null);
        ilg.Emit(OpCodes.Ret);

        // Emit an entry point method; this must be in a
        // non-generic type.
        TypeBuilder dummy = myModule.DefineType("Dummy",
            TypeAttributes.Class | TypeAttributes.NotPublic);
        MethodBuilder entryPoint = dummy.DefineMethod("Main",
            MethodAttributes.Public | MethodAttributes.Static,
            null, null);
        ilg = entryPoint.GetILGenerator();
        // In order to call the static generic method GM, it is
        // necessary to create a constructed type from the
        // generic type definition for Sample. This can be any
        // constructed type; in this case Sample<int> is used.
        Type SampleOfInt =
            myType.MakeGenericType( typeof(int) );
        // Next get a MethodInfo representing the static generic
        // method GM on type Sample<int>.
        MethodInfo SampleOfIntGM = TypeBuilder.GetMethod(SampleOfInt,
            genMethod);
        // Next get a MethodInfo for GM<string>, which is the
        // instantiation of GM that Main calls.
        MethodInfo GMOfString =
            SampleOfIntGM.MakeGenericMethod( typeof(string) );
        // Finally, emit the call. Push a string onto
        // the stack, as the argument for the generic method.
        ilg.Emit(OpCodes.Ldstr, "Hello, world!");
        ilg.EmitCall(OpCodes.Call, GMOfString, null);
        ilg.Emit(OpCodes.Ret);

        myType.CreateType();
        dummy.CreateType();
        myAssembly.SetEntryPoint(entryPoint);
        myAssembly.Save(myAsmName.Name + ".exe");

        Console.WriteLine(myAsmName.Name + ".exe has been saved.");
    }
}
Imports System.Reflection
Imports System.Reflection.Emit

' Compare the MSIL in this class to the MSIL
' generated by the Reflection.Emit code in class
' Example.
Public Class Sample(Of T)
    Public Field As T
    Public Shared Sub GM(Of U)(ByVal val As U)
        Dim s As New Sample(Of U)
        s.Field = val
        Console.WriteLine(s.Field)
    
    End Sub
End Class 

Public Class Example
    
    Public Shared Sub Main() 
        Dim myDomain As AppDomain = AppDomain.CurrentDomain
        Dim myAsmName As New AssemblyName("TypeBuilderGetFieldExample")
        Dim myAssembly As AssemblyBuilder = _
            myDomain.DefineDynamicAssembly(myAsmName, _
                AssemblyBuilderAccess.Save)
        Dim myModule As ModuleBuilder = _
            myAssembly.DefineDynamicModule(myAsmName.Name, _
                myAsmName.Name & ".exe")
        
        ' Define the sample type.
        Dim myType As TypeBuilder = myModule.DefineType( _
            "Sample", _
            TypeAttributes.Class Or TypeAttributes.Public)
        
        ' Add a type parameter, making the type generic.
        Dim typeParamNames() As String = { "T" }
        Dim typeParams As GenericTypeParameterBuilder() = _
            myType.DefineGenericParameters(typeParamNames)
        
        ' Define a default constructor. Normally it would 
        ' not be necessary to define the default constructor,
        ' but in this case it is needed for the call to
        ' TypeBuilder.GetConstructor, which gets the default
        ' constructor for the generic type constructed from 
        ' Sample(Of T), in the generic method GM(Of U).
        Dim ctor As ConstructorBuilder = _
            myType.DefineDefaultConstructor( _
                MethodAttributes.PrivateScope Or MethodAttributes.Public _
                Or MethodAttributes.HideBySig Or MethodAttributes.SpecialName _
                Or MethodAttributes.RTSpecialName)
        
        ' Add a field of type T, with the name Field.
        Dim myField As FieldBuilder = myType.DefineField( _
            "Field", typeParams(0), FieldAttributes.Public)
        
        ' Add a method and make it generic, with a type 
        ' parameter named U. Note how similar this is to 
        ' the way Sample is turned into a generic type. The
        ' method has no signature, because the type of its
        ' only parameter is U, which is not yet defined.
        Dim genMethod As MethodBuilder = _
            myType.DefineMethod("GM", _
                MethodAttributes.Public Or MethodAttributes.Static)
        Dim methodParamNames() As String = { "U" }
        Dim methodParams As GenericTypeParameterBuilder() = _
            genMethod.DefineGenericParameters(methodParamNames)

        ' Now add a signature for genMethod, specifying U
        ' as the type of the parameter. There is no return value
        ' and no custom modifiers.
        genMethod.SetSignature(Nothing, Nothing, Nothing, _
            New Type() { methodParams(0) }, Nothing, Nothing)
        
        ' Emit a method body for the generic method.
        Dim ilg As ILGenerator = genMethod.GetILGenerator()
        ' Construct the type Sample(Of U) using MakeGenericType.
        Dim SampleOfU As Type = _
            myType.MakeGenericType(methodParams(0))
        ' Create a local variable to store the instance of
        ' Sample(Of U).
        ilg.DeclareLocal(SampleOfU)
        ' Call the default constructor. Note that it is 
        ' necessary to have the default constructor for the
        ' constructed generic type Sample(Of U); use the 
        ' TypeBuilder.GetConstructor method to obtain this 
        ' constructor.
        Dim ctorOfU As ConstructorInfo = _
            TypeBuilder.GetConstructor(SampleOfU, ctor)
        ilg.Emit(OpCodes.Newobj, ctorOfU)
        ' Store the instance in the local variable; load it
        ' again, and load the parameter of genMethod.
        ilg.Emit(OpCodes.Stloc_0)
        ilg.Emit(OpCodes.Ldloc_0)
        ilg.Emit(OpCodes.Ldarg_0)
        ' In order to store the value in the field of the
        ' instance of Sample(Of U), it is necessary to have 
        ' a FieldInfo representing the field of the 
        ' constructed type. Use TypeBuilder.GetField to 
        ' obtain this FieldInfo.
        Dim FieldOfU As FieldInfo = _
            TypeBuilder.GetField(SampleOfU, myField)
        ' Store the value in the field. 
        ilg.Emit(OpCodes.Stfld, FieldOfU)
        ' Load the instance, load the field value, box it
        ' (specifying the type of the type parameter, U), 
        ' and print it.
        ilg.Emit(OpCodes.Ldloc_0)
        ilg.Emit(OpCodes.Ldfld, FieldOfU)
        ilg.Emit(OpCodes.Box, methodParams(0))
        Dim writeLineObj As MethodInfo = _
            GetType(Console).GetMethod("WriteLine", _
                New Type() {GetType(Object)})
        ilg.EmitCall(OpCodes.Call, writeLineObj, Nothing)
        ilg.Emit(OpCodes.Ret)
        
        ' Emit an entry point method; this must be in a
        ' non-generic type.
        Dim dummy As TypeBuilder = _
            myModule.DefineType("Dummy", _
                TypeAttributes.Class Or TypeAttributes.NotPublic)
        Dim entryPoint As MethodBuilder = _
            dummy.DefineMethod("Main", _
                MethodAttributes.Public Or MethodAttributes.Static, _
                Nothing, Nothing)
        ilg = entryPoint.GetILGenerator()
        ' In order to call the static generic method GM, it is
        ' necessary to create a constructed type from the 
        ' generic type definition for Sample. This can be ANY
        ' constructed type; in this case Sample(Of Integer)
        ' is used.
        Dim SampleOfInt As Type = _
            myType.MakeGenericType(GetType(Integer))
        ' Next get a MethodInfo representing the static generic
        ' method GM on type Sample(Of Integer).
        Dim SampleOfIntGM As MethodInfo = _
            TypeBuilder.GetMethod(SampleOfInt, genMethod)
        ' Next get a MethodInfo for GM(Of String), which is the 
        ' instantiation of generic method GM that is called
        ' by Sub Main.
        Dim GMOfString As MethodInfo = _
            SampleOfIntGM.MakeGenericMethod(GetType(String))
        ' Finally, emit the call. Push a string onto
        ' the stack, as the argument for the generic method.
        ilg.Emit(OpCodes.Ldstr, "Hello, world!")
        ilg.EmitCall(OpCodes.Call, GMOfString, Nothing)
        ilg.Emit(OpCodes.Ret)
        
        myType.CreateType()
        dummy.CreateType()
        myAssembly.SetEntryPoint(entryPoint)
        myAssembly.Save(myAsmName.Name & ".exe")
        
        Console.WriteLine(myAsmName.Name & ".exe has been saved.")
    
    End Sub 
End Class

Hinweise

Die GetField -Methode bietet eine Möglichkeit, ein FieldInfo -Objekt abzurufen, das ein Feld eines konstruierten generischen Typs darstellt, dessen generische Typdefinition durch ein TypeBuilder -Objekt dargestellt wird.

Angenommen, Sie verfügen über ein TypeBuilder Objekt, das den Typ G<T> in der C#-Syntax (G(Of T)in Visual Basic in C++) darstellt, und ein FieldBuilder Objekt, generic <T> ref class G das ein Feld public T F in der C#-Syntax (Public F As Tin Visual Basic in C++) darstellt, public: T F das durch G<T>definiert wird. Angenommen, die G<T> über eine generische Methode mit typparameter verfügtU, die eine instance des erstellten Typs G<U> erstellt und das Feld F für diesen instance aufruft. Um den Funktionsaufruf auszugeben, benötigen Sie ein FieldInfo -Objekt, das für den konstruierten F Typ darstellt, d. h. das ist vom Typ U statt vom Typ T. Rufen Sie hierzu zunächst die MakeGenericType -Methode für das TypeBuilder -Objekt auf, und geben Sie das GenericTypeParameterBuilder Objekt an, das als Typargument dargestellt wird U . Rufen Sie dann die GetField -Methode mit dem Rückgabewert der MakeGenericType -Methode als Parameter type und dem -Objekt auf, das FieldBuilder als Parameter fielddarstelltF. Der Rückgabewert ist das Objekt, das FieldInfo Sie zum Ausgeben des Funktionsaufrufs benötigen. Das Codebeispiel veranschaulicht dieses Szenario.

Gilt für:

GetField(String, BindingFlags)

Quelle:
TypeBuilder.cs

Gibt das vom angegebenen Namen angegebene Feld zurück.

public:
 override System::Reflection::FieldInfo ^ GetField(System::String ^ name, System::Reflection::BindingFlags bindingAttr);
public override System.Reflection.FieldInfo? GetField (string name, System.Reflection.BindingFlags bindingAttr);
public override System.Reflection.FieldInfo GetField (string name, System.Reflection.BindingFlags bindingAttr);
override this.GetField : string * System.Reflection.BindingFlags -> System.Reflection.FieldInfo
Public Overrides Function GetField (name As String, bindingAttr As BindingFlags) As FieldInfo

Parameter

name
String

Der Name des abzurufenden Felds.

bindingAttr
BindingFlags

Dies muss ein Bitflag aus BindingFlags wie in InvokeMethod, NonPublic usw. sein.

Gibt zurück

Gibt das FieldInfo-Objekt zurück, das das Feld darstellt, das von diesem Typ mit dem angegebenen Namen und dem öffentlichen oder nicht öffentlichen Modifizierer deklariert oder geerbt wurde. Wenn keine Übereinstimmungen vorhanden sind, wird null zurückgegeben.

Ausnahmen

Diese Methode ist für unvollständige Typen nicht implementiert.

Hinweise

Rufen Sie den Typ mithilfe von Type.GetType oder Assembly.GetType ab, und verwenden Sie reflektion für den abgerufenen Typ.

Gilt für: