TypeBuilder.GetField Metode

Definisi

Ruang nama:

System.Reflection.Emit

Rakitan:

System.Reflection.Emit.dll

Mengembalikan bidang yang ditentukan oleh saat ini TypeBuilder.

Overload

GetField(Type, FieldInfo)	Mengembalikan bidang dari jenis generik yang dibuat yang ditentukan yang sesuai dengan bidang yang ditentukan dari definisi jenis generik.
GetField(String, BindingFlags)	Mengembalikan bidang yang ditentukan oleh nama yang diberikan.

GetField(Type, FieldInfo)

Sumber:

RuntimeTypeBuilder.cs

Mengembalikan bidang dari jenis generik yang dibuat yang ditentukan yang sesuai dengan bidang yang ditentukan dari definisi jenis generik.

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

Jenis generik yang dibangun yang bidangnya dikembalikan.

field

FieldInfo

Bidang pada definisi jenis generik , typeyang menentukan bidang type mana yang akan dikembalikan.

Mengembalikan

FieldInfo

Objek FieldInfo yang mewakili bidang type yang sesuai dengan field, yang menentukan bidang milik definisi jenis generik .type

Pengecualian

ArgumentException

type tidak mewakili jenis generik.

-atau-

type bukan berjenis TypeBuilder.

-atau-

Jenis field deklarasikan bukan definisi jenis generik.

-atau-

Jenis field deklarasikan bukan definisi jenis generik dari type.

Contoh

Contoh kode berikut berisi kode sumber untuk kelas generik bernama Sampel yang memiliki parameter jenis bernama T. Kelas memiliki bidang bernama Field, dari jenis T, dan metode generik bernama GM dengan parameter jenisnya sendiri, bernama U. Metode GM membuat instans Sample, menggantikan parameter U jenisnya sendiri untuk parameter Samplejenis , dan menyimpan parameter inputnya di Field. Kode sumber ini dikompilasi tetapi tidak digunakan; Anda dapat melihatnya dengan Ildasm.exe (Il Disassembler) dan membandingkannya dengan kode yang dipancarkan oleh kelas Example.

Kode di kelas Example menunjukkan penggunaan metode untuk memancarkan GetField kode generik. Metode Main kelas Example membuat rakitan dinamis yang berisi kelas bernama Sample, dan menggunakan DefineGenericParameters metode untuk membuatnya generik dengan menambahkan parameter jenis bernama T. Konstruktor tanpa parameter dan bidang bernama Field, dari jenis T, ditambahkan ke kelas Sample. Metode GM ditambahkan dan diubah menjadi metode generik dengan menggunakan MethodBuilder.DefineGenericParameters metode . Parameter jenis GM diberi nama U. Setelah parameter jenis ditentukan, tanda tangan GM ditambahkan dengan menggunakan MethodBuilder.SetSignature metode . Tidak ada jenis pengembalian dan tidak ada pengubah yang diperlukan atau kustom, sehingga semua parameter metode null ini kecuali parameterTypes; parameterTypes mengatur jenis parameter satu-satunya metode ke U, parameter jenis generik metode. Isi metode membuat instans dari jenis Sample<U> yang dibangun (Sample(Of U) di Visual Basic), menetapkan parameter metode ke Field, lalu mencetak nilai Field. Metode GetField ini digunakan untuk membuat FieldInfo yang mewakili bidang jenis Sample<U> generik yang dibangun dalam OpCodes.Stfld instruksi dan OpCodes.Ldfld .

Jenis dummy didefinisikan untuk menahan metode Maintitik masuk . Dalam isi Main, metode statis GM dipanggil pada jenis Sample<int> generik yang dibangun (Sample(Of Integer) di Visual Basic), dengan jenis String diganti untuk U.

Saat contoh kode dijalankan, kode menyimpan rakitan yang dipancarkan sebagai TypeBuilderGetFieldExample.exe. Anda dapat menjalankan TypeBuilderGetFieldExample.exe, dan Anda dapat menggunakan Ildasm.exe (Il Disassembler) untuk membandingkan kode yang dipancarkan dengan kode untuk Sample kelas yang dikompilasi ke dalam contoh kode itu sendiri.

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

Keterangan

Metode ini GetField menyediakan cara untuk mendapatkan FieldInfo objek yang mewakili bidang dari jenis generik yang dibangun yang definisi jenis generiknya diwakili oleh TypeBuilder objek.

Misalnya, Anda memiliki TypeBuilder objek yang mewakili jenis G<T> dalam sintaks C# (G(Of T) di Visual Basic, generic <T> ref class G di C++) dan FieldBuilder objek yang mewakili bidang public T F dalam sintaks C# (Public F As T dalam Visual Basic, public: T F di C++) yang ditentukan oleh G<T>. Misalkan memiliki G<T> metode generik dengan parameter U jenis yang membuat instans jenis G<U> yang dibangun dan memanggil bidang F pada instans tersebut. Untuk memancarkan panggilan fungsi, Anda memerlukan FieldInfo objek yang mewakili pada jenis yang dibangun - dengan kata lain, yang berjenis FU daripada jenis T. Untuk melakukan ini, pertama-tama panggil MakeGenericType metode pada TypeBuilder objek , menentukan GenericTypeParameterBuilder objek yang mewakili U sebagai argumen jenis. Kemudian panggil GetField metode dengan nilai MakeGenericType pengembalian metode sebagai parameter type dan FieldBuilder objek yang mewakili F sebagai parameter field. Nilai yang dikembalikan adalah objek yang FieldInfo Anda butuhkan untuk memancarkan panggilan fungsi. Contoh kode menunjukkan skenario ini.

GetField(String, BindingFlags)

Mengembalikan bidang yang ditentukan oleh nama yang diberikan.

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

Parameter

name

String

Nama bidang yang akan didapatkan.

bindingAttr

BindingFlags

Ini harus sedikit bendera dari BindingFlags seperti dalam InvokeMethod, NonPublic, dan sebagainya.

Mengembalikan

FieldInfo

Mengembalikan objek yang FieldInfo mewakili bidang yang dideklarasikan atau diwarisi oleh tipe ini dengan nama yang ditentukan dan pengubah publik atau non-publik. Jika tidak ada kecocokan maka null dikembalikan.

Pengecualian

NotSupportedException

Metode ini tidak diimplementasikan untuk jenis yang tidak lengkap.

Keterangan

Ambil jenis menggunakan Type.GetType atau Assembly.GetType dan gunakan pantulan pada jenis yang diambil.