FieldBuilder Classe

Definição

public ref class FieldBuilder sealed : System::Reflection::FieldInfo, System::Runtime::InteropServices::_FieldBuilder

public ref class FieldBuilder sealed : System::Reflection::FieldInfo

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class FieldBuilder : System.Reflection.FieldInfo, System.Runtime.InteropServices._FieldBuilder

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class FieldBuilder : System.Reflection.FieldInfo, System.Runtime.InteropServices._FieldBuilder

public sealed class FieldBuilder : System.Reflection.FieldInfo

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type FieldBuilder = class
    inherit FieldInfo
    interface _FieldBuilder

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type FieldBuilder = class
    inherit FieldInfo
    interface _FieldBuilder

type FieldBuilder = class
    inherit FieldInfo

Public NotInheritable Class FieldBuilder
Inherits FieldInfo
Implements _FieldBuilder

Public NotInheritable Class FieldBuilder
Inherits FieldInfo

Herança

Object

MemberInfo

FieldInfo

FieldBuilder

Atributos

ClassInterfaceAttribute ComVisibleAttribute

Implementações

_FieldBuilder

Exemplos

O exemplo a seguir ilustra o uso da FieldBuilder classe.

using System;
using System.Reflection;
using System.Reflection.Emit;

public class FieldBuilder_Sample
{
    private static Type? CreateType()
    {
        // Create an assembly.
        AssemblyName assemName = new AssemblyName();
        assemName.Name = "DynamicAssembly";
        AssemblyBuilder assemBuilder =
                       AssemblyBuilder.DefineDynamicAssembly(assemName, AssemblyBuilderAccess.Run);
        // Create a dynamic module in Dynamic Assembly.
        ModuleBuilder modBuilder = assemBuilder.DefineDynamicModule("DynamicModule");
        // Define a public class named "DynamicClass" in the assembly.
        TypeBuilder typBuilder = modBuilder.DefineType("DynamicClass", TypeAttributes.Public);

        // Define a private String field named "DynamicField" in the type.
        FieldBuilder fldBuilder = typBuilder.DefineField("DynamicField",
            typeof(string), FieldAttributes.Private | FieldAttributes.Static);
        // Create the constructor.
        Type[] constructorArgs = { typeof(String) };
        ConstructorBuilder constructor = typBuilder.DefineConstructor(
           MethodAttributes.Public, CallingConventions.Standard, constructorArgs);
        ILGenerator constructorIL = constructor.GetILGenerator();
        constructorIL.Emit(OpCodes.Ldarg_0);
        ConstructorInfo? superConstructor = typeof(Object).GetConstructor(new Type[0]);
        constructorIL.Emit(OpCodes.Call, superConstructor!);
        constructorIL.Emit(OpCodes.Ldarg_0);
        constructorIL.Emit(OpCodes.Ldarg_1);
        constructorIL.Emit(OpCodes.Stfld, fldBuilder);
        constructorIL.Emit(OpCodes.Ret);

        // Create the DynamicMethod method.
        MethodBuilder methBuilder = typBuilder.DefineMethod("DynamicMethod",
                             MethodAttributes.Public, typeof(String), null);
        ILGenerator methodIL = methBuilder.GetILGenerator();
        methodIL.Emit(OpCodes.Ldarg_0);
        methodIL.Emit(OpCodes.Ldfld, fldBuilder);
        methodIL.Emit(OpCodes.Ret);

        Console.WriteLine($"Name               : {fldBuilder.Name}");
        Console.WriteLine($"DeclaringType      : {fldBuilder.DeclaringType}");
        Console.WriteLine($"Type               : {fldBuilder.FieldType}");
        return typBuilder.CreateType();
    }

    public static void Main()
    {
        Type? dynType = CreateType();
        try
        {
            if (dynType is not null)
            {
                // Create an instance of the "HelloWorld" class.
                Object? helloWorld = Activator.CreateInstance(dynType, new Object[] { "HelloWorld" });
                // Invoke the "DynamicMethod" method of the "DynamicClass" class.
                Object? obj = dynType.InvokeMember("DynamicMethod",
                               BindingFlags.InvokeMethod, null, helloWorld, null);
                Console.WriteLine($"DynamicClass.DynamicMethod returned: \"{obj}\"");
            }
        }
        catch (MethodAccessException e)
        {
            Console.WriteLine($"{e.GetType().Name}: {e.Message}");
        }
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Public Module FieldBuilder_Sample
   Private Function CreateType() As Type
      ' Create an assembly.
      Dim assemName As New AssemblyName()
      assemName.Name = "DynamicAssembly"
      Dim assemBuilder As AssemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemName,
                                                AssemblyBuilderAccess.Run)
      ' Create a dynamic module in Dynamic Assembly.
      Dim modBuilder As ModuleBuilder = assemBuilder.DefineDynamicModule("DynamicModule")
      ' Define a public class named "DynamicClass" in the assembly.
      Dim typBuilder As TypeBuilder = modBuilder.DefineType("DynamicClass", 
                                          TypeAttributes.Public)
      ' Define a private String field named "DynamicField" in the type.
      Dim fldBuilder As FieldBuilder = typBuilder.DefineField("DynamicField",
                  GetType(String), FieldAttributes.Private Or FieldAttributes.Static)
      ' Create the constructor.
      Dim constructorArgs As Type() = {GetType(String)}
      Dim constructor As ConstructorBuilder = 
                  typBuilder.DefineConstructor(MethodAttributes.Public, 
                           CallingConventions.Standard, constructorArgs)
      Dim constructorIL As ILGenerator = constructor.GetILGenerator()
      constructorIL.Emit(OpCodes.Ldarg_0)
      Dim superConstructor As ConstructorInfo = GetType(Object).GetConstructor(New Type() {})
      constructorIL.Emit(OpCodes.Call, superConstructor)
      constructorIL.Emit(OpCodes.Ldarg_0)
      constructorIL.Emit(OpCodes.Ldarg_1)
      constructorIL.Emit(OpCodes.Stfld, fldBuilder)
      constructorIL.Emit(OpCodes.Ret)

      ' Create the DynamicMethod method.
      Dim methBuilder As MethodBuilder = typBuilder.DefineMethod("DynamicMethod", 
                        MethodAttributes.Public, GetType(String), Nothing)
      Dim methodIL As ILGenerator = methBuilder.GetILGenerator()
      methodIL.Emit(OpCodes.Ldarg_0)
      methodIL.Emit(OpCodes.Ldfld, fldBuilder)
      methodIL.Emit(OpCodes.Ret)

      Console.WriteLine($"Name               : {fldBuilder.Name}")
      Console.WriteLine($"DeclaringType      : {fldBuilder.DeclaringType}")
      Console.WriteLine($"Type               : {fldBuilder.FieldType}")
      Return typBuilder.CreateType()
   End Function 

   Public Sub Main()
      Dim dynType As Type = CreateType()
      Try  
        ' Create an instance of the "HelloWorld" class.
         Dim helloWorld As Object = Activator.CreateInstance(dynType, New Object() {"HelloWorld"})
         ' Invoke the "DynamicMethod" method of the "DynamicClass" class.
         Dim obj As Object = dynType.InvokeMember("DynamicMethod", 
                  BindingFlags.InvokeMethod, Nothing, helloWorld, Nothing)
         Console.WriteLine($"DynamicClass.DynamicMethod returned: ""{obj}""")
      Catch e As MethodAccessException
            Console.WriteLine($"{e.GetType().Name}: {e.Message}")
      End Try
   End Sub 
End Module

Comentários

Obter uma instância de FieldBuilder chamando DefineField, DefineInitializedDataou DefineUninitializedData.