TypeBuilder.GetField Método

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Retorna um campo definido pelo TypeBuilder atual.

Sobrecargas

GetField(Type, FieldInfo)	Retorna o campo de tipo genérico construído especificado que corresponde ao campo especificado da definição de tipo genérico.
GetField(String, BindingFlags)	Retorna o campo especificado pelo nome fornecido.

GetField(Type, FieldInfo)

Origem:

RuntimeTypeBuilder.cs

Retorna o campo de tipo genérico construído especificado que corresponde ao campo especificado da definição de tipo genérico.

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

Parâmetros

type

Type

O tipo genérico construído cujo campo será retornado.

field

FieldInfo

Um campo na definição de tipo genérico de type, que especifica qual campo de type será retornado.

Retornos

FieldInfo

Um objeto FieldInfo que representa o campo de type correspondente a field, que especifica um campo pertencente à definição de tipo genérico de type.

Exceções

ArgumentException

type não representa um tipo genérico.

- ou -

type não é do tipo TypeBuilder.

- ou -

O tipo declarativo de field não é uma definição de tipo genérico.

- ou -

O tipo declarativo de field não é a definição de tipo genérico de type.

Exemplos

O exemplo de código a seguir contém o código-fonte de uma classe genérica chamada Sample que tem um parâmetro de tipo chamado T. A classe tem um campo chamado Field, do tipo Te um método genérico chamado GM com seu próprio parâmetro de tipo, chamado U. O método GM cria uma instância de Sample, substituindo seu próprio parâmetro U de tipo para o parâmetro de tipo de Samplee armazena seu parâmetro de entrada em Field. Esse código-fonte é compilado, mas não usado; você pode exibi-lo com o Ildasm.exe (Il Disassembler) e compará-lo com o código emitido pela classe Example.

O código na classe Example demonstra o uso do GetField método para emitir código genérico. O Main método da classe Example cria um assembly dinâmico que contém uma classe chamada Samplee usa o DefineGenericParameters método para torná-lo genérico adicionando um parâmetro de tipo chamado T. Um construtor sem parâmetros e um campo chamado Field, do tipo T, são adicionados à classe Sample. Um método GM é adicionado e transformado em um método genérico usando o MethodBuilder.DefineGenericParameters método . O parâmetro de tipo de GM é chamado U. Depois que o parâmetro de tipo é definido, a assinatura de GM é adicionada usando o MethodBuilder.SetSignature método . Não há nenhum tipo de retorno e nenhum modificador obrigatório ou personalizado, portanto, todos os parâmetros desse método são null exceto parameterTypes; parameterTypes define o tipo do único parâmetro do método como U, o parâmetro de tipo genérico do método. O corpo do método cria uma instância do tipo Sample<U> construído (Sample(Of U) no Visual Basic), atribui o parâmetro do método a Fielde, em seguida, imprime o valor de Field. O GetField método é usado para criar um FieldInfo que representa o campo do tipo Sample<U> genérico construído nas OpCodes.Stfld instruções e OpCodes.Ldfld .

Um tipo fictício é definido para manter o método Mainde ponto de entrada . No corpo de Main, o método estático GM é invocado no tipo Sample<int> genérico construído (Sample(Of Integer) no Visual Basic), com o tipo String substituído por U.

Quando o exemplo de código é executado, ele salva o assembly emitido como TypeBuilderGetFieldExample.exe. Você pode executar TypeBuilderGetFieldExample.exe e pode usar o Ildasm.exe (IL Disassembler) para comparar o código emitido com o código da Sample classe que é compilada no próprio exemplo de código.

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

Comentários

O GetField método fornece uma maneira de obter um FieldInfo objeto que representa um campo de um tipo genérico construído cuja definição de tipo genérico é representada por um TypeBuilder objeto .

Por exemplo, suponha que você tenha um TypeBuilder objeto que representa o tipo G<T> na sintaxe C# (G(Of T) no Visual Basic, generic <T> ref class G em C++) e um FieldBuilder objeto que representa um campo public T F na sintaxe C# (Public F As T no Visual Basic, public: T F em C++) definido por G<T>. Suponha que tenha G<T> um método genérico com o parâmetro U type que cria uma instância do tipo G<U> construído e o campo F de chamadas nessa instância. Para emitir a chamada de função, você precisa de um FieldInfo objeto que represente no tipo construído , em outras F palavras, que seja do tipo U em vez do tipo T. Para fazer isso, primeiro chame o MakeGenericType método no TypeBuilder objeto , especificando o GenericTypeParameterBuilder objeto que representa U como o argumento de tipo. Em seguida, chame o GetField método com o valor retornado do MakeGenericType método como parâmetro type e o FieldBuilder objeto que representa F como parâmetro field. O valor retornado é o FieldInfo objeto que você precisa para emitir a chamada de função. O exemplo de código demonstra esse cenário.

GetField(String, BindingFlags)

Retorna o campo especificado pelo nome fornecido.

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

Parâmetros

name

String

O nome do campo a ser obtido.

bindingAttr

BindingFlags

Esse deve ser um sinalizador de bit de BindingFlags, tal como em InvokeMethod, NonPublic e assim por diante.

Retornos

FieldInfo

Retorna o objeto FieldInfo que representa o campo declarado ou herdado por esse tipo com o nome especificado e o modificador público ou não público. Se não houver correspondências, null será retornado.

Exceções

NotSupportedException

Esse método não está implementado para tipos incompletos.

Comentários

Recupere o tipo usando Type.GetType ou Assembly.GetType e use reflexão no tipo recuperado.