FieldBuilder Classe

Définition

Espace de noms:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Source:

FieldBuilder.cs

Définit et représente un champ. Cette classe ne peut pas être héritée.

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

public abstract class FieldBuilder : System.Reflection.FieldInfo

type FieldBuilder = class
    inherit FieldInfo

Public MustInherit Class FieldBuilder
Inherits FieldInfo

Héritage

Object

MemberInfo

FieldInfo

FieldBuilder

Exemples

L’exemple suivant illustre l’utilisation de la 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

Remarques

Obtenez une instance de FieldBuilder en appelant DefineField, DefineInitializedDataou DefineUninitializedData.

Notes

La SetValue méthode n’est actuellement pas prise en charge. Pour contourner ce problème, récupérez le FieldInfo en réfléchissant sur le type terminé et l’appel SetValue pour définir la valeur du champ.

Constructeurs

FieldBuilder()

Initialise une nouvelle instance de la classe FieldBuilder.

Propriétés

Attributes	Indique les attributs de ce champ. Cette propriété est en lecture seule.
CustomAttributes	Obtient une collection qui contient les attributs personnalisés de ce membre. (Hérité de MemberInfo)
DeclaringType	Indique une référence à l'objet Type pour le type qui déclare ce champ. Cette propriété est en lecture seule.
FieldHandle	Indique le handle de métadonnées interne de ce champ. Cette propriété est en lecture seule.
FieldType	Indique l'objet Type qui représente le type de ce champ. Cette propriété est en lecture seule.
IsAssembly	Obtient une valeur indiquant si la visibilité potentielle de ce champ est décrite par Assembly, c'est-à-dire si le champ est visible au maximum par d'autres types du même assembly, et n'est pas visible par des types dérivés à l'extérieur de l'assembly. (Hérité de FieldInfo)
IsCollectible	Obtient une valeur qui indique si cet objet MemberInfo fait partie d’un assembly contenu dans un AssemblyLoadContext pouvant être collecté. (Hérité de MemberInfo)
IsFamily	Obtient une valeur indiquant si la visibilité de ce champ est décrite par Family, c'est-à-dire si le champ est visible uniquement dans sa classe et dans ses classes dérivées. (Hérité de FieldInfo)
IsFamilyAndAssembly	Obtient une valeur indiquant si la visibilité de ce champ est décrite par FamANDAssem, c'est-à-dire si le champ peut faire l'objet d'un accès par des classes dérivées, mais uniquement si elles se trouvent dans le même assembly. (Hérité de FieldInfo)
IsFamilyOrAssembly	Obtient une valeur indiquant si la visibilité potentielle de ce champ est décrite par FamORAssem, c'est-à-dire si le champ peut faire l'objet d'un accès par des classes dérivées où qu'elles se trouvent, et par des classes du même assembly. (Hérité de FieldInfo)
IsInitOnly	Obtient une valeur indiquant si le champ peut uniquement être défini dans le corps du constructeur. (Hérité de FieldInfo)
IsLiteral	Obtient une valeur indiquant si la valeur est écrite au moment de la compilation et si elle n'est pas modifiable. (Hérité de FieldInfo)
IsNotSerialized	Obsolète. Obtient une valeur indiquant si ce champ est doté de l'attribut NotSerialized. (Hérité de FieldInfo)
IsPinvokeImpl	Obtient une valeur indiquant si l'attribut PinvokeImpl correspondant est défini dans FieldAttributes. (Hérité de FieldInfo)
IsPrivate	Obtient une valeur indiquant si le champ est privé. (Hérité de FieldInfo)
IsPublic	Obtient une valeur indiquant si le champ est public. (Hérité de FieldInfo)
IsSecurityCritical	Obtient une valeur qui indique si le champ actuel est critique de sécurité (security-critical) ou critique sécurisé (security-safe-critical) au niveau de confiance actuel. (Hérité de FieldInfo)
IsSecuritySafeCritical	Obtient une valeur qui indique si le champ actuel est critique sécurisé au niveau de confiance actuel. (Hérité de FieldInfo)
IsSecurityTransparent	Obtient une valeur qui indique si le champ actuel est transparent au niveau de confiance actuel. (Hérité de FieldInfo)
IsSpecialName	Obtient une valeur indiquant si l'attribut SpecialName correspondant est défini dans l'énumérateur FieldAttributes. (Hérité de FieldInfo)
IsStatic	Obtient une valeur indiquant si le champ est statique. (Hérité de FieldInfo)
MemberType	Obtient une valeur MemberTypes indiquant que ce membre est un champ. (Hérité de FieldInfo)
MetadataToken	Obtient un jeton qui identifie le module dynamique actuel dans les métadonnées.
Module	Obtient le module dans lequel le type qui contient ce champ est défini.
Name	Indique le nom de ce champ. Cette propriété est en lecture seule.
ReflectedType	Indique la référence à l'objet Type à partir duquel cet objet a été obtenu. Cette propriété est en lecture seule.

Méthodes

Equals(Object)	Retourne une valeur qui indique si cette instance est égale à un objet spécifié. (Hérité de FieldInfo)
GetCustomAttributes(Boolean)	Retourne tous les attributs personnalisés définis pour ce champ.
GetCustomAttributes(Type, Boolean)	Retourne tous les attributs personnalisés définis pour ce champ et identifiés par le type donné.
GetCustomAttributesData()	Renvoie une liste d’objets CustomAttributeData représentant des données sur les attributs qui ont été appliqués au membre cible. (Hérité de MemberInfo)
GetHashCode()	Retourne le code de hachage de cette instance. (Hérité de FieldInfo)
GetModifiedFieldType()	Obtient le type modifié de cet objet de champ. (Hérité de FieldInfo)
GetOptionalCustomModifiers()	Obtient un tableau de types identifiant les modificateurs personnalisés facultatifs du champ. (Hérité de FieldInfo)
GetRawConstantValue()	Retourne une valeur littérale associée au champ par un compilateur. (Hérité de FieldInfo)
GetRequiredCustomModifiers()	Obtient un tableau de types identifiant les modificateurs personnalisés requis de la propriété. (Hérité de FieldInfo)
GetType()	Identifie les attributs d’un champ de classe et donne accès à ses métadonnées. (Hérité de FieldInfo)
GetValue(Object)	Récupère la valeur du champ pris en charge par l'objet donné.
GetValueDirect(TypedReference)	Retourne la valeur d'un champ pris en charge par un objet donné. (Hérité de FieldInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Définit et représente un champ. Cette classe ne peut pas être héritée. (Hérité de MemberInfo)
IsDefined(Type, Boolean)	Indique si un attribut doté du type spécifié est défini sur un champ.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
SetConstant(Object)	Définit la valeur par défaut de ce champ.
SetConstantCore(Object)	En cas de substitution dans une classe dérivée, définit la valeur par défaut de ce champ.
SetCustomAttribute(ConstructorInfo, Byte[])	Définit un attribut personnalisé à l’aide d’un objet blob d’attribut personnalisé spécifié.
SetCustomAttribute(CustomAttributeBuilder)	Définit un attribut personnalisé à l’aide d’un générateur d’attributs personnalisés.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	En cas de substitution dans une classe dérivée, définit un attribut personnalisé sur cet assembly.
SetOffset(Int32)	Spécifie la disposition du champ.
SetOffsetCore(Int32)	En cas de substitution dans une classe dérivée, spécifie la disposition de champ.
SetValue(Object, Object)	Définit la valeur du champ pris en charge par l’objet donné. (Hérité de FieldInfo)
SetValue(Object, Object, BindingFlags, Binder, CultureInfo)	Définit la valeur du champ pris en charge par l’objet donné.
SetValueDirect(TypedReference, Object)	Définit la valeur du champ pris en charge par l’objet donné. (Hérité de FieldInfo)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Méthodes d’extension

GetCustomAttribute(MemberInfo, Type)	Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.
GetCustomAttribute(MemberInfo, Type, Boolean)	Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.
GetCustomAttribute<T>(MemberInfo)	Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.
GetCustomAttribute<T>(MemberInfo, Boolean)	Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.
GetCustomAttributes(MemberInfo)	Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié.
GetCustomAttributes(MemberInfo, Boolean)	Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.
GetCustomAttributes(MemberInfo, Type)	Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.
GetCustomAttributes(MemberInfo, Type, Boolean)	Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.
GetCustomAttributes<T>(MemberInfo)	Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.
GetCustomAttributes<T>(MemberInfo, Boolean)	Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié, et inspecte éventuellement les ancêtres de ce membre.
IsDefined(MemberInfo, Type)	Indique si des attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié.
IsDefined(MemberInfo, Type, Boolean)	Indique si les attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié, et, éventuellement, appliqués à ses ancêtres.
GetMetadataToken(MemberInfo)	Obtient un jeton de métadonnées pour le membre donné, s’il est disponible.
HasMetadataToken(MemberInfo)	Retourne une valeur qui indique si un jeton de métadonnées est disponible pour le membre spécifié.