TypeBuilder.GetField 方法

定义

命名空间:

System.Reflection.Emit

程序集:

System.Reflection.Emit.dll

返回由当前 TypeBuilder 定义的字段。

重载

GetField(Type, FieldInfo)	返回指定的构造泛型类型的字段，该字段对应于泛型类型定义的指定字段。
GetField(String, BindingFlags)	返回由给定名称指定的字段。

GetField(Type, FieldInfo)

Source:

RuntimeTypeBuilder.cs

返回指定的构造泛型类型的字段，该字段对应于泛型类型定义的指定字段。

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

参数

type

Type

返回其字段的构造泛型类型。

field

FieldInfo

type 的泛型类型定义中的一个字段，用于指定要返回 type 的哪一个字段。

返回

FieldInfo

FieldInfo 对象，它表示与 field 对应的 type 的字段，用于指定属于 type 的泛型类型定义的字段。

例外

ArgumentException

type 不表示泛型类型。

- 或 -

type 的类型不是 TypeBuilder。

- 或 -

field 的声明类型不是一个泛型类型定义。

- 或 -

field 的声明类型不是 type 的泛型类型定义。

示例

下面的代码示例包含名为 Sample 的泛型类的源代码，该类具有名为 的类型 T参数。 类具有一个名为 Field、类型 T为 的字段和一个名为 的 GM 泛型方法，以及其自己的类型参数名为 的泛型 U方法。 方法 GM 创建 的 Sample实例，将自己的类型参数 U 替换为 的类型 Sample参数，并将其输入参数存储在 中 Field。 此源代码已编译，但未使用;可以使用 Ildasm.exe (IL 反汇编程序) 查看它，并将其与类 Example发出的代码进行比较。

类 Example 中的代码演示如何使用 GetField 方法发出泛型代码。 Main类Example的 方法创建包含名为 Sample的类的动态程序集，并使用 DefineGenericParameters 方法通过添加名为 的类型参数使其成为泛型T。 无参数构造函数和名为 Field的字段（类型 T为 ）添加到类 Sample。 使用 MethodBuilder.DefineGenericParameters 方法GM添加方法并将其转换为泛型方法。 的类型 GM 参数名为 U。 定义类型参数后，使用 MethodBuilder.SetSignature 方法添加 的GM签名。 没有返回类型，也没有必需的或自定义修饰符，因此此方法的所有参数都 null 除外 parameterTypes; parameterTypes 将方法的唯一参数的类型设置为 U，该方法的泛型类型参数。 方法的主体在 Visual Basic) 中创建构造类型 Sample<U> (Sample(Of U) 实例，将方法的 参数 Field分配给 ，然后打印 的值 Field。 方法GetField用于创建一个 ，FieldInfo它表示 和 OpCodes.Ldfld 指令中OpCodes.Stfld构造的泛型类型的Sample<U>字段。

虚拟类型定义为保存入口点方法 Main。 在 的Main主体中，对 Visual Basic) 中构造的泛型类型 Sample<int> (Sample(Of Integer) 调用静态GM方法，类型String将U替换为 。

运行代码示例时，它会将发出的程序集保存为 TypeBuilderGetFieldExample.exe。 可以运行 TypeBuilderGetFieldExample.exe，并且可以使用 Ildasm.exe (IL 反汇编程序) 将发出的代码与编译为代码示例本身的 Sample 类的代码进行比较。

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

注解

方法 GetField 提供了一 FieldInfo 种获取 对象的方法，该对象表示构造的泛型类型的字段，其泛型类型定义由 TypeBuilder 对象表示。

例如，假设你有一个 TypeBuilder 对象，该对象表示 G<T> Visual Basic generic <T> ref class G 中 C# 语法 (G(Of T)、C++) 中的类型，以及一个FieldBuilder对象，该对象表示在 Visual Basic 中public: T F、C++) 中定义的 G<T>C# 语法 (Public F As T 字段public T F。 G<T>假设 有一个具有类型参数U的泛型方法，该方法创建构造类型的G<U>实例并在该实例上调用字段F。 为了发出函数调用，需要一个 FieldInfo 对象，该对象表示 F 在构造的类型上 - 换句话说，该对象的类型为 类型 U ，而不是类型 T。 为此，请首先对 TypeBuilder 对象调用 MakeGenericType 方法，并GenericTypeParameterBuilder指定表示U为类型参数的对象。 然后，GetField使用方法的MakeGenericType返回值作为参数，并将FieldBuilder表示F为参数 type 的对象调用 方法field。 返回值是 FieldInfo 发出函数调用所需的对象。 代码示例演示了此方案。

GetField(String, BindingFlags)

返回由给定名称指定的字段。

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

要获取的字段的名称。

bindingAttr

BindingFlags

这必须是 BindingFlags 中的位标志，类似于 InvokeMethod、NonPublic 等中的位标志。

返回

FieldInfo

返回 FieldInfo 对象，该对象表示由此类型声明或继承的具有指定名称和公共或非公共修饰符的字段。 如果没有匹配项，则返回 null。

例外

NotSupportedException

不会为不完整类型实现此方法。

注解

使用 Type.GetType 或 Assembly.GetType 检索类型，并在检索的类型上使用反射。