TypeBuilder.GetField TypeBuilder.GetField TypeBuilder.GetField TypeBuilder.GetField Method

定义

返回由当前 TypeBuilder 定义的字段。Returns a field defined by the current TypeBuilder.

重载

GetField(String, BindingFlags) GetField(String, BindingFlags) GetField(String, BindingFlags) GetField(String, BindingFlags)

返回由给定名称指定的字段。Returns the field specified by the given name.

GetField(Type, FieldInfo) GetField(Type, FieldInfo) GetField(Type, FieldInfo)

返回指定的构造泛型类型的字段,该字段对应于泛型类型定义的指定字段。Returns the field of the specified constructed generic type that corresponds to the specified field of the generic type definition.

GetField(String, BindingFlags) GetField(String, BindingFlags) GetField(String, BindingFlags) GetField(String, BindingFlags)

返回由给定名称指定的字段。Returns the field specified by the given name.

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);
override this.GetField : string * System.Reflection.BindingFlags -> System.Reflection.FieldInfo
Public Overrides Function GetField (name As String, bindingAttr As BindingFlags) As FieldInfo

参数

name
String String String String

要获取的字段的名称。The name of the field to get.

bindingAttr
BindingFlags BindingFlags BindingFlags BindingFlags

这必须是 BindingFlags 中的位标志,类似于 InvokeMethodNonPublic 等中的位标志。This must be a bit flag from BindingFlags as in InvokeMethod, NonPublic, and so on.

返回

返回 FieldInfo 对象,该对象表示由此类型声明或继承的具有指定名称和公共或非公共修饰符的字段。Returns the FieldInfo object representing the field declared or inherited by this type with the specified name and public or non-public modifier. 如果没有匹配项,则返回 nullIf there are no matches then null is returned.

异常

不会为不完整类型实现此方法。This method is not implemented for incomplete types.

注解

使用Type.GetTypeAssembly.GetType检索类型,并对检索到的类型使用反射。Retrieve the type using Type.GetType or Assembly.GetType and use reflection on the retrieved type.

GetField(Type, FieldInfo) GetField(Type, FieldInfo) GetField(Type, FieldInfo)

返回指定的构造泛型类型的字段,该字段对应于泛型类型定义的指定字段。Returns the field of the specified constructed generic type that corresponds to the specified field of the generic type definition.

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

参数

type
Type Type Type Type

返回其字段的构造泛型类型。The constructed generic type whose field is returned.

field
FieldInfo FieldInfo FieldInfo FieldInfo

type 的泛型类型定义中的一个字段,用于指定要返回 type 的哪一个字段。A field on the generic type definition of type, which specifies which field of type to return.

返回

FieldInfo 对象,它表示与 field 对应的 type 的字段,用于指定属于 type 的泛型类型定义的字段。A FieldInfo object that represents the field of type corresponding to field, which specifies a field belonging to the generic type definition of type.

异常

type 不表示泛型类型。type does not represent a generic type.

-or- type 的类型不是 TypeBuildertype is not of type TypeBuilder.

-or- field 的声明类型不是一个泛型类型定义。The declaring type of field is not a generic type definition.

-or- field 的声明类型不是 type 的泛型类型定义。The declaring type of field is not the generic type definition of type.

示例

下面的代码示例包含一个名为 Sample 的泛型类的源代码,该类具有一个名T为的类型参数。The following code example contains source code for a generic class named Sample that has a type parameter named T. 类具有Field一个名为、类型T为的字段GM和一个名为的泛型方法,该方法具有其U自己的类型参数(名为)。The class has a field named Field, of type T, and a generic method named GM with its own type parameter, named U. 方法GM创建的Sample实例,将其自己的类型参数U替换为的类型参数Sample,并在中Field存储其输入参数。Method GM creates an instance of Sample, substituting its own type parameter U for the type parameter of Sample, and stores its input parameter in Field. 已编译但未使用此源代码;您可以使用Ildasm (IL 拆装器)查看它并将其与类Example发出的代码进行比较。This source code is compiled but not used; you can view it with the Ildasm.exe (IL Disassembler) and compare it to the code emitted by class Example.

Example中的代码演示如何使用GetField方法发出泛型代码。The code in class Example demonstrates the use of the GetField method to emit generic code. Main Sample DefineGenericParameters T的方法创建一个动态程序集,其中包含一个名为的类,并使用方法通过添加一个名为的类型参数使其成为泛型。 ExampleThe Main method of class Example creates a dynamic assembly containing a class named Sample, and uses the DefineGenericParameters method to make it generic by adding a type parameter named T. 向类Field T添加了一个无参数的构造函数和一个名为的类型Sample为的字段。A parameterless constructor and a field named Field, of type T, are added to class Sample. 使用方法添加并转换为泛型方法的方法GMMethodBuilder.DefineGenericParametersA method GM is added and turned into a generic method by using the MethodBuilder.DefineGenericParameters method. GM类型参数命名U为。The type parameter of GM is named U. 定义类型参数后, GM MethodBuilder.SetSignature使用方法添加的签名。After the type parameter is defined, the signature of GM is added by using the MethodBuilder.SetSignature method. 没有返回类型,并且没有必需的修饰符或自定义修饰符,因此此方法null的所有参数除外; parameterTypes将方法的唯一参数的类型设置为U,方法的泛型类型参数。 parameterTypesThere is no return type and no required or custom modifiers, so all the parameters of this method are null except parameterTypes; parameterTypes sets the type of the method's only parameter to U, the method's generic type parameter. 方法的Sample<U>主体创建构造类型的实例(Sample(Of U)在 Visual Basic 中),将该方法的参数分配给Field,然后输出的值FieldThe body of the method creates an instance of the constructed type Sample<U> (Sample(Of U) in Visual Basic), assigns the method's parameter to Field, and then prints the value of Field. GetField方法用于Sample<U>创建,它表示OpCodes.StfldOpCodes.Ldfld说明中构造的泛型类型的字段。 FieldInfoThe GetField method is used to create a FieldInfo that represents the field of the constructed generic type Sample<U> in the OpCodes.Stfld and OpCodes.Ldfld instructions.

定义了一个虚拟类型来容纳入口点方法MainA dummy type is defined to hold the entry-point method Main. 在的Main正文中,将对GM构造的泛型类型Sample<int>Sample(Of Integer)在 Visual Basic 中)调用静态方法,并将String类型替换U为。In the body of Main, the static GM method is invoked on the constructed generic type Sample<int> (Sample(Of Integer) in Visual Basic), with type String substituted for U.

运行代码示例时,它会将发出的程序集保存为 TypeBuilderGetFieldExample。When the code example is run, it saves the emitted assembly as TypeBuilderGetFieldExample.exe. 您可以运行 TypeBuilderGetFieldExample,并且可以使用Ildasm (IL 拆装器)将发出的代码与编译到代码示例本身中的Sample类的代码进行比较。You can run TypeBuilderGetFieldExample.exe, and you can use the Ildasm.exe (IL Disassembler) to compare the emitted code with the code for the Sample class that is compiled into the code example itself.

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 

注解

方法提供了一种方法,用于FieldInfo获取表示构造泛型类型(其泛型类型TypeBuilder定义由对象表示)的字段的对象。 GetFieldThe GetField method provides a way to get a FieldInfo object that represents a field of a constructed generic type whose generic type definition is represented by a TypeBuilder object.

例如TypeBuilder ,假设您有一个对象,该对象表示语法中C#的类型G(Of T) G<T> (在 Visual Basic generic <T> ref class G中C++ public T F ,在中FieldBuilder为),而对象C#Public F As T public: T F由定义G<T>的语法(在C++中为 Visual Basic)。For example, suppose you have a TypeBuilder object that represents the type G<T> in C# syntax (G(Of T) in Visual Basic, generic <T> ref class G in C++) and a FieldBuilder object that represents a field public T F in C# syntax (Public F As T in Visual Basic, public: T F in C++) that is defined by G<T>. 假设有一个具有类型参数U的泛型方法,该方法创建构造类型G<U>的实例并调用该实例上的字段。 F G<T>Suppose that G<T> has a generic method with type parameter U that creates an instance of the constructed type G<U> and calls field F on that instance. 为了发出函数调用, FieldInfo你需要一个对象,该对象表示F构造类型(即类型为类型U ,而不是类型T)。In order to emit the function call, you need a FieldInfo object that represents F on the constructed type - in other words, that is of type U rather than type T. 为此MakeGenericType ,请先对TypeBuilder对象调用方法,并指定GenericTypeParameterBuilder表示U为类型参数的对象。To do this, first call the MakeGenericType method on the TypeBuilder object, specifying the GenericTypeParameterBuilder object that represents U as the type argument. 然后,调用GetField方法,并将MakeGenericType方法的返回值作为参数type ,并FieldBuilder将表示F为参数field的对象。Then call the GetField method with the return value of the MakeGenericType method as parameter type and the FieldBuilder object that represents F as parameter field. 返回值是发出函数FieldInfo调用所需的对象。The return value is the FieldInfo object you need to emit the function call. 此代码示例演示了这种情况。The code example demonstrates this scenario.

适用于