TypeBuilder.GetField Metoda

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

netstandard.dll, System.Reflection.Emit.dll

Vrátí pole definované aktuálním TypeBuilderpolem .

Přetížení

Name	Description
GetField(Type, FieldInfo)	Vrátí pole zadaného vytvořeného obecného typu, které odpovídá zadanému poli definice obecného typu.
GetField(String, BindingFlags)	Vrátí pole určené daným názvem.

GetField(Type, FieldInfo)

Zdroj:

TypeBuilder.cs

Vrátí pole zadaného vytvořeného obecného typu, které odpovídá zadanému poli definice obecného typu.

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

Parametry

type

Type

Vytvořený obecný typ, jehož pole je vráceno.

field

FieldInfo

Pole pro definici typeobecného typu , která určuje, které pole type se má vrátit.

Návraty

FieldInfo

ObjektFieldInfo, který představuje pole type odpovídající field, který určuje pole patřící do definice obecného typu .type

Výjimky

ArgumentException

type nepředstavuje obecný typ.

nebo

type není typu TypeBuilder.

nebo

Deklarující typ field není definice obecného typu.

nebo

Deklarující typ field není obecnou definicí typetypu .

Příklady

Následující příklad kódu obsahuje zdrojový kód pro obecnou třídu s názvem Sample, která má parametr typu s názvem T. Třída má pole s názvem Field, typu Ta obecnou metodu s vlastním GM parametrem typu s názvem U. Metoda GM vytvoří instanci Sample, nahrazení vlastního parametru typu U parametru typu parametru Sample, a uloží jeho vstupní parametr do Field. Tento zdrojový kód je zkompilován, ale nepoužívá se; můžete jej zobrazit pomocí Ildasm.exe (IL Disassembler) a porovnat ho s kódem vygenerovaným třídou Example.

Kód ve třídě Example ukazuje použití GetField metody k generování obecného kódu. Main Metoda třídy Example vytvoří dynamické sestavení obsahující třídu pojmenovanou Sample, a používá metodu DefineGenericParameters k vytvoření obecné přidáním parametru typu s názvem T. Konstruktor bez parametrů a pole s názvem Field, typu T, jsou přidány do třídy Sample. Metoda GM je přidána a převedena na obecnou metodu MethodBuilder.DefineGenericParameters pomocí metody. Parametr GM typu s názvem U. Po definování parametru typu se podpis GM přidá pomocí MethodBuilder.SetSignature metody. Neexistuje žádný návratový typ a žádné povinné ani vlastní modifikátory, takže všechny parametry této metody jsou null s výjimkou parameterTypes; parameterTypes nastaví typ jediného parametru metody na U, parametr obecného typu metody. Tělo metody vytvoří instanci vytvořeného typu Sample<U> (Sample(Of U) v Visual Basic), přiřadí parametr metody Field a potom vytiskne hodnotu Field. Metoda GetField se používá k vytvořeníFieldInfo, který představuje pole vytvořeného obecného typu Sample<U> v OpCodes.Stfld pokynech.OpCodes.Ldfld

Fiktivní typ je definován pro uložení metody Mainvstupního bodu . V těle Main je statická metoda GM vyvolána u vytvořeného obecného typu Sample<int> (Sample(Of Integer) v Visual Basic) s typem String nahrazena U.

Při spuštění příkladu kódu uloží generované sestavení jako TypeBuilderGetFieldExample.exe. Můžete spustit TypeBuilderGetFieldExample.exea můžete použít Ildasm.exe (IL Disassembler) k porovnání generovaného kódu s kódem Sample třídy, která je zkompilována do samotného příkladu kódu.

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

Poznámky

Metoda GetField poskytuje způsob, jak získat FieldInfo objekt, který představuje pole vytvořeného obecného typu, jehož definice obecného typu je reprezentována objektem TypeBuilder .

Předpokládejme například, že máte objekt představující typ v syntaxi jazyka C# ( v Visual Basic) a < objekt />, který představuje pole v syntaxi jazyka C# ( v Visual Basic), které je definováno . Předpokládejme, že G<T> má obecnou metodu s parametrem U typu, který vytvoří instanci vytvořeného typu G<U> a volá pole F pro danou instanci. Chcete-li generovat volání funkce, potřebujete FieldInfo objekt, který představuje F na vytvořeném typu - jinými slovy, to je typ U , nikoli typ T. Provedete to tak, že nejprve zavoláte metodu MakeGenericType objektu TypeBuilder , který GenericTypeParameterBuilder představuje U jako argument typu. Potom zavolejte metodu s návratovou GetField hodnotou metody jako parametr MakeGenericType a type objekt, který představuje FieldBuilder jako parametr F.field Návratová hodnota je FieldInfo objekt, který potřebujete k vygenerování volání funkce. Tento scénář ukazuje příklad kódu.

GetField(String, BindingFlags)

Vrátí pole určené daným názvem.

public:
 override System::Reflection::FieldInfo ^ GetField(System::String ^ name, System::Reflection::BindingFlags bindingAttr);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)]
public override System.Reflection.FieldInfo? GetField(string name, System.Reflection.BindingFlags bindingAttr);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)>]
override this.GetField : string * System.Reflection.BindingFlags -> System.Reflection.FieldInfo

Public Overrides Function GetField (name As String, bindingAttr As BindingFlags) As FieldInfo

Parametry

name

String

Název pole, které chcete získat.

bindingAttr

BindingFlags

Musí to být trochu příznak od BindingFlags in InvokeMethod, NonPublica tak dále.

Návraty

FieldInfo

FieldInfo Vrátí objekt představující pole deklarované nebo zděděné tímto typem se zadaným názvem a veřejným nebo neveřejným modifikátorem. Pokud neexistují žádné shody, null vrátí se.

Atributy

DynamicallyAccessedMembersAttribute

Výjimky

NotSupportedException

Tato metoda není implementována pro neúplné typy.

Poznámky

Načtěte typ pomocí Type.GetType nebo Assembly.GetType použijte reflexi načteného typu.