MethodBuilder Classe

Définition

Espace de noms:

System.Reflection.Emit

Assembly:

mscorlib.dll

Définit et représente une méthode (ou constructeur) sur une classe dynamique.

public ref class MethodBuilder sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder

Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder

Héritage

Object

MemberInfo

MethodBase

MethodInfo

MethodBuilder

Attributs

ClassInterfaceAttribute ComVisibleAttribute

Implémente

_MethodBuilder

Exemples

L’exemple suivant utilise la MethodBuilder classe pour créer une méthode dans un type dynamique.

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

class DemoMethodBuilder
{
    public static void AddMethodDynamically (TypeBuilder myTypeBld,
                                             string mthdName,
                                             Type[] mthdParams,
                                             Type returnType,
                                             string mthdAction)
    {

        MethodBuilder myMthdBld = myTypeBld.DefineMethod(
                                             mthdName,
                                             MethodAttributes.Public |
                                             MethodAttributes.Static,
                                             returnType,
                                             mthdParams);

        ILGenerator ILout = myMthdBld.GetILGenerator();

        int numParams = mthdParams.Length;

        for (byte x=0; x < numParams; x++)
        {
            ILout.Emit(OpCodes.Ldarg_S, x);
        }

        if (numParams > 1)
        {
            for (int y=0; y<(numParams-1); y++)
            {
                switch (mthdAction)
                {
                    case "A": ILout.Emit(OpCodes.Add);
                              break;
                    case "M": ILout.Emit(OpCodes.Mul);
                              break;
                    default: ILout.Emit(OpCodes.Add);
                              break;
                }
            }
        }
        ILout.Emit(OpCodes.Ret);
    }

    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName asmName = new AssemblyName();
        asmName.Name = "MyDynamicAsm";

        AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                                       asmName,
                                       AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule("MyDynamicAsm",
                                                                  "MyDynamicAsm.dll");

        TypeBuilder myTypeBld = myModule.DefineType("MyDynamicType",
                                                    TypeAttributes.Public);

        // Get info from the user to build the method dynamically.
        Console.WriteLine("Let's build a simple method dynamically!");
        Console.WriteLine("Please enter a few numbers, separated by spaces.");
        string inputNums = Console.ReadLine();
        Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ");
        string myMthdAction = Console.ReadLine().ToUpper();
        Console.Write("Lastly, what do you want to name your new dynamic method? ");
        string myMthdName = Console.ReadLine();

        // Process inputNums into an array and create a corresponding Type array
        int index = 0;
        string[] inputNumsList = inputNums.Split();

        Type[] myMthdParams = new Type[inputNumsList.Length];
        object[] inputValsList = new object[inputNumsList.Length];

        foreach (string inputNum in inputNumsList)
        {
            inputValsList[index] = (object)Convert.ToInt32(inputNum);
                myMthdParams[index] = typeof(int);
                index++;
        }

        // Now, call the method building method with the parameters, passing the
        // TypeBuilder by reference.
        AddMethodDynamically(myTypeBld,
                             myMthdName,
                             myMthdParams,
                             typeof(int),
                             myMthdAction);

        Type myType = myTypeBld.CreateType();

        Console.WriteLine("---");
        Console.WriteLine("The result of {0} the inputted values is: {1}",
                          ((myMthdAction == "M") ? "multiplying" : "adding"),
                          myType.InvokeMember(myMthdName,
                          BindingFlags.InvokeMethod | BindingFlags.Public |
                          BindingFlags.Static,
                          null,
                          null,
                          inputValsList));
        Console.WriteLine("---");

        // Let's take a look at the method we created.
        // If you are interested in seeing the MSIL generated dynamically for the method
        // your program generated, change to the directory where you ran the compiled
        // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
        // of manifest contents appears, click on "MyDynamicType" and then on the name of
        // of the method you provided during execution.

        myAsmBuilder.Save("MyDynamicAsm.dll");

        MethodInfo myMthdInfo = myType.GetMethod(myMthdName);
        Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString());
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Class DemoMethodBuilder
   
   Public Shared Sub AddMethodDynamically(ByVal myTypeBld As TypeBuilder, _
                                          ByVal mthdName As String, _
                                          ByVal mthdParams() As Type, _
                                          ByVal returnType As Type, _
                                          ByVal mthdAction As String)
      
      Dim myMthdBld As MethodBuilder = myTypeBld.DefineMethod(mthdName, _
                                       MethodAttributes.Public Or MethodAttributes.Static, _
                                       returnType, _
                                       mthdParams)
      
      Dim ILout As ILGenerator = myMthdBld.GetILGenerator()
      
      Dim numParams As Integer = mthdParams.Length
      
      Dim x As Byte
      For x = 0 To numParams - 1
         ILout.Emit(OpCodes.Ldarg_S, x)
      Next x
      
      If numParams > 1 Then
         Dim y As Integer
         For y = 0 To (numParams - 1) - 1
            Select Case mthdAction
               Case "A"
                  ILout.Emit(OpCodes.Add)
               Case "M"
                  ILout.Emit(OpCodes.Mul)
               Case Else
                  ILout.Emit(OpCodes.Add)
            End Select
         Next y
      End If
      ILout.Emit(OpCodes.Ret)
   End Sub 
    
   
   Public Shared Sub Main()
      
      Dim myDomain As AppDomain = AppDomain.CurrentDomain
      Dim asmName As New AssemblyName()
      asmName.Name = "MyDynamicAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(asmName, _
                                            AssemblyBuilderAccess.RunAndSave)
      
      Dim myModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyDynamicAsm", _
                                                                       "MyDynamicAsm.dll")
      
      Dim myTypeBld As TypeBuilder = myModule.DefineType("MyDynamicType", TypeAttributes.Public)
      
      ' Get info from the user to build the method dynamically.
      Console.WriteLine("Let's build a simple method dynamically!")
      Console.WriteLine("Please enter a few numbers, separated by spaces.")
      Dim inputNums As String = Console.ReadLine()
      Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ")
      Dim myMthdAction As String = Console.ReadLine().ToUpper()
      Console.Write("Lastly, what do you want to name your new dynamic method? ")
      Dim myMthdName As String = Console.ReadLine()
      
      ' Process inputNums into an array and create a corresponding Type array 
      Dim index As Integer = 0
      Dim inputNumsList As String() = inputNums.Split()
      
      Dim myMthdParams(inputNumsList.Length - 1) As Type
      Dim inputValsList(inputNumsList.Length - 1) As Object
      
      
      Dim inputNum As String
      For Each inputNum In  inputNumsList
         inputValsList(index) = CType(Convert.ToInt32(inputNum), Object)
         myMthdParams(index) = GetType(Integer)
         index += 1
      Next inputNum
      
      ' Now, call the method building method with the parameters, passing the 
      ' TypeBuilder by reference.
      AddMethodDynamically(myTypeBld, myMthdName, myMthdParams, GetType(Integer), myMthdAction)
      
      Dim myType As Type = myTypeBld.CreateType()
     
      Dim description as String 
      If myMthdAction = "M" Then
         description = "multiplying"
      Else
         description = "adding"
      End If

      Console.WriteLine("---")
      Console.WriteLine("The result of {0} the values is: {1}", _
                         description, _
                         myType.InvokeMember(myMthdName, _
                                             BindingFlags.InvokeMethod _
                                               Or BindingFlags.Public _
                                               Or BindingFlags.Static, _
                                             Nothing, _
                                             Nothing, _
                                             inputValsList)) 
      Console.WriteLine("---")

      ' If you are interested in seeing the MSIL generated dynamically for the method
      ' your program generated, change to the directory where you ran the compiled
      ' code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
      ' of manifest contents appears, click on "MyDynamicType" and then on the name of
      ' of the method you provided during execution.
 
      myAsmBuilder.Save("MyDynamicAsm.dll") 

      Dim myMthdInfo As MethodInfo = myType.GetMethod(myMthdName)
      Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString())
   End Sub 
End Class

Remarques

Pour plus d’informations sur cette API, consultez les remarques d’API supplémentaires pour MethodBuilder.

Propriétés

Nom	Description
Attributes	Récupère les attributs de cette méthode.
CallingConvention	Retourne la convention d’appel de la méthode.
ContainsGenericParameters	Non pris en charge pour ce type.
CustomAttributes	Obtient une collection qui contient les attributs personnalisés de ce membre. (Hérité de MemberInfo)
DeclaringType	Retourne le type qui déclare cette méthode.
InitLocals	Obtient ou définit une valeur booléenne qui spécifie si les variables locales de cette méthode sont initialisées à zéro. La valeur par défaut de cette propriété est true.
IsAbstract	Obtient une valeur indiquant si la méthode est abstraite. (Hérité de MethodBase)
IsAssembly	Obtient une valeur indiquant si la visibilité potentielle de cette méthode ou de ce constructeur est décrite par Assembly; autrement dit, la méthode ou le constructeur est visible au maximum par d’autres types dans le même assembly et n’est pas visible par les types dérivés en dehors de l’assembly. (Hérité de MethodBase)
IsConstructor	Obtient une valeur indiquant si la méthode est un constructeur. (Hérité de MethodBase)
IsFamily	Obtient une valeur indiquant si la visibilité de cette méthode ou constructeur est décrite par Family; autrement dit, la méthode ou le constructeur est visible uniquement dans sa classe et ses classes dérivées. (Hérité de MethodBase)
IsFamilyAndAssembly	Obtient une valeur indiquant si la visibilité de cette méthode ou constructeur est décrite par FamANDAssem; autrement dit, la méthode ou le constructeur peut être appelé par des classes dérivées, mais uniquement s’ils se trouvent dans le même assembly. (Hérité de MethodBase)
IsFamilyOrAssembly	Obtient une valeur indiquant si la visibilité potentielle de cette méthode ou de ce constructeur est décrite par FamORAssem; autrement dit, la méthode ou le constructeur peut être appelé par des classes dérivées où qu’elles soient, et par des classes dans le même assembly. (Hérité de MethodBase)
IsFinal	Obtient une valeur indiquant si cette méthode est final. (Hérité de MethodBase)
IsGenericMethod	Obtient une valeur indiquant si la méthode est une méthode générique.
IsGenericMethodDefinition	Obtient une valeur indiquant si l’objet actuel MethodBuilder représente la définition d’une méthode générique.
IsHideBySig	Obtient une valeur indiquant si seul un membre du même type avec exactement la même signature est masqué dans la classe dérivée. (Hérité de MethodBase)
IsPrivate	Obtient une valeur indiquant si ce membre est privé. (Hérité de MethodBase)
IsPublic	Obtient une valeur indiquant s’il s’agit d’une méthode publique. (Hérité de MethodBase)
IsSecurityCritical	Lève une NotSupportedException dans tous les cas.
IsSecuritySafeCritical	Lève une NotSupportedException dans tous les cas.
IsSecurityTransparent	Lève une NotSupportedException dans tous les cas.
IsSpecialName	Obtient une valeur indiquant si cette méthode a un nom spécial. (Hérité de MethodBase)
IsStatic	Obtient une valeur indiquant si la méthode est static. (Hérité de MethodBase)
IsVirtual	Obtient une valeur indiquant si la méthode est virtual. (Hérité de MethodBase)
MemberType	Obtient une MemberTypes valeur indiquant que ce membre est une méthode. (Hérité de MethodInfo)
MetadataToken	Obtient une valeur qui identifie un élément de métadonnées. (Hérité de MemberInfo)
MethodHandle	Récupère le handle interne de la méthode. Utilisez ce handle pour accéder au handle de métadonnées sous-jacent.
MethodImplementationFlags	Obtient les MethodImplAttributes indicateurs qui spécifient les attributs d’une implémentation de méthode. (Hérité de MethodBase)
Module	Obtient le module dans lequel la méthode actuelle est définie.
Name	Récupère le nom de cette méthode.
ReflectedType	Récupère la classe utilisée dans la réflexion pour obtenir cet objet.
ReturnParameter	Obtient un ParameterInfo objet qui contient des informations sur le type de retour de la méthode, par exemple si le type de retour a des modificateurs personnalisés.
ReturnType	Obtient le type de retour de la méthode représentée par ce MethodBuilder.
ReturnTypeCustomAttributes	Retourne les attributs personnalisés du type de retour de la méthode.
Signature	Récupère la signature de la méthode.

Méthodes

Nom	Description
AddDeclarativeSecurity(SecurityAction, PermissionSet)	Ajoute une sécurité déclarative à cette méthode.
CreateDelegate(Type, Object)	Crée un délégué du type spécifié avec la cible spécifiée à partir de cette méthode. (Hérité de MethodInfo)
CreateDelegate(Type)	Crée un délégué du type spécifié à partir de cette méthode. (Hérité de MethodInfo)
CreateMethodBody(Byte[], Int32)	Crée le corps de la méthode à l’aide d’un tableau d’octets fourni de Microsoft instructions MSIL (Intermediate Language).
DefineGenericParameters(String[])	Définit le nombre de paramètres de type générique pour la méthode actuelle, spécifie leurs noms et retourne un tableau d’objets GenericTypeParameterBuilder qui peuvent être utilisés pour définir leurs contraintes.
DefineParameter(Int32, ParameterAttributes, String)	Définit les attributs de paramètre et le nom d’un paramètre de cette méthode, ou de la valeur de retour de cette méthode. Retourne un ParameterBuilder qui peut être utilisé pour appliquer des attributs personnalisés.
Equals(Object)	Détermine si l’objet donné est égal à cette instance.
GetBaseDefinition()	Retourne l’implémentation de base d’une méthode.
GetCustomAttributes(Boolean)	Retourne tous les attributs personnalisés définis pour cette méthode.
GetCustomAttributes(Type, Boolean)	Retourne les attributs personnalisés identifiés par le type donné.
GetCustomAttributesData()	Retourne 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)
GetGenericArguments()	Retourne un tableau d’objets GenericTypeParameterBuilder qui représentent les paramètres de type de la méthode, s’il est générique.
GetGenericMethodDefinition()	Retourne cette méthode.
GetHashCode()	Obtient le code de hachage de cette méthode.
GetILGenerator()	Retourne un ILGenerator pour cette méthode avec une taille de flux msIL (Microsoft language intermédiaire) par défaut de 64 octets.
GetILGenerator(Int32)	Retourne un ILGenerator pour cette méthode avec la taille de flux MSIL (Microsoft intermediate Language) spécifiée.
GetMethodBody()	En cas de substitution dans une classe dérivée, obtient un MethodBody objet qui fournit l’accès au flux MSIL, aux variables locales et aux exceptions pour la méthode actuelle. (Hérité de MethodBase)
GetMethodImplementationFlags()	Retourne les indicateurs d’implémentation de la méthode.
GetModule()	Retourne une référence au module qui contient cette méthode.
GetParameters()	Retourne les paramètres de cette méthode.
GetToken()	Retourne le MethodToken jeton de cette méthode.
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Appelle dynamiquement la méthode reflétée par cette instance sur l’objet donné, en passant les paramètres spécifiés et sous les contraintes du classeur donné.
IsDefined(Type, Boolean)	Vérifie si le type d’attribut personnalisé spécifié est défini.
MakeGenericMethod(Type[])	Retourne une méthode générique construite à partir de la définition de méthode générique actuelle à l’aide des arguments de type générique spécifiés.
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Définit un attribut personnalisé à l’aide d’un objet blob d’attributs personnalisé spécifié.
SetCustomAttribute(CustomAttributeBuilder)	Définit un attribut personnalisé à l’aide d’un générateur d’attributs personnalisé.
SetImplementationFlags(MethodImplAttributes)	Définit les indicateurs d’implémentation pour cette méthode.
SetMarshal(UnmanagedMarshal)	Obsolète. Définit les informations de marshaling pour le type de retour de cette méthode.
SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)	Crée le corps de la méthode à l’aide d’un tableau d’octets spécifié de Microsoft instructions MSIL (Intermediate Language).
SetParameters(Type[])	Définit le nombre et les types de paramètres d’une méthode.
SetReturnType(Type)	Définit le type de retour de la méthode.
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	Définit la signature de méthode, y compris le type de retour, les types de paramètres et les modificateurs personnalisés obligatoires et facultatifs du type de retour et des types de paramètres.
SetSymCustomAttribute(String, Byte[])	Définissez un attribut personnalisé symbolique à l’aide d’un objet blob.
ToString()	Retourne cette MethodBuilder instance sous forme de chaîne.

Implémentations d’interfaces explicites

Nom	Description
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de MemberInfo)
_MemberInfo.GetType()	Obtient un Type objet représentant la MemberInfo classe. (Hérité de MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface. (Hérité de MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)	Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l’accès aux propriétés et méthodes exposées par un objet. (Hérité de MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de MethodBase)
_MethodBase.GetType()	Pour obtenir une description de ce membre, consultez GetType(). (Hérité de MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface. (Hérité de MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)	Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l’accès aux propriétés et méthodes exposées par un objet. (Hérité de MethodBase)
_MethodBase.IsAbstract	Pour obtenir une description de ce membre, consultez IsAbstract. (Hérité de MethodBase)
_MethodBase.IsAssembly	Pour obtenir une description de ce membre, consultez IsAssembly. (Hérité de MethodBase)
_MethodBase.IsConstructor	Pour obtenir une description de ce membre, consultez IsConstructor. (Hérité de MethodBase)
_MethodBase.IsFamily	Pour obtenir une description de ce membre, consultez IsFamily. (Hérité de MethodBase)
_MethodBase.IsFamilyAndAssembly	Pour obtenir une description de ce membre, consultez IsFamilyAndAssembly. (Hérité de MethodBase)
_MethodBase.IsFamilyOrAssembly	Pour obtenir une description de ce membre, consultez IsFamilyOrAssembly. (Hérité de MethodBase)
_MethodBase.IsFinal	Pour obtenir une description de ce membre, consultez IsFinal. (Hérité de MethodBase)
_MethodBase.IsHideBySig	Pour obtenir une description de ce membre, consultez IsHideBySig. (Hérité de MethodBase)
_MethodBase.IsPrivate	Pour obtenir une description de ce membre, consultez IsPrivate. (Hérité de MethodBase)
_MethodBase.IsPublic	Pour obtenir une description de ce membre, consultez IsPublic. (Hérité de MethodBase)
_MethodBase.IsSpecialName	Pour obtenir une description de ce membre, consultez IsSpecialName. (Hérité de MethodBase)
_MethodBase.IsStatic	Pour obtenir une description de ce membre, consultez IsStatic. (Hérité de MethodBase)
_MethodBase.IsVirtual	Pour obtenir une description de ce membre, consultez IsVirtual. (Hérité de MethodBase)
_MethodBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.
_MethodBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface.
_MethodBuilder.GetTypeInfoCount(UInt32)	Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).
_MethodBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l’accès aux propriétés et méthodes exposées par un objet.
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)	Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de MethodInfo)
_MethodInfo.GetType()	Fournit l’accès à la GetType() méthode à partir de COM. (Hérité de MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)	Récupère les informations de type d’un objet, qui peuvent être utilisées pour obtenir les informations de type d’une interface. (Hérité de MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)	Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)	Fournit l’accès aux propriétés et méthodes exposées par un objet. (Hérité de MethodInfo)

Méthodes d’extension

Nom	Description
GetCustomAttribute(MemberInfo, Type, Boolean)	Récupère un attribut personnalisé d’un type spécifié appliqué à un membre spécifié et inspecte éventuellement les ancêtres de ce membre.
GetCustomAttribute(MemberInfo, Type)	Récupère un attribut personnalisé d’un type spécifié appliqué à un membre spécifié.
GetCustomAttribute<T>(MemberInfo, Boolean)	Récupère un attribut personnalisé d’un type spécifié 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é appliqué à un membre spécifié.
GetCustomAttributes(MemberInfo, Boolean)	Récupère une collection d’attributs personnalisés appliqués à un membre spécifié et inspecte éventuellement les ancêtres de ce membre.
GetCustomAttributes(MemberInfo, Type, Boolean)	Récupère 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(MemberInfo, Type)	Récupère une collection d’attributs personnalisés d’un type spécifié qui sont appliqués à un membre spécifié.
GetCustomAttributes(MemberInfo)	Récupère une collection d’attributs personnalisés appliqués à un membre spécifié.
GetCustomAttributes<T>(MemberInfo, Boolean)	Récupère 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)	Récupère une collection d’attributs personnalisés d’un type spécifié qui sont appliqués à un membre spécifié.
GetRuntimeBaseDefinition(MethodInfo)	Récupère un objet qui représente la méthode spécifiée sur la classe de base directe ou indirecte où la méthode a été déclarée pour la première fois.
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.
IsDefined(MemberInfo, Type)	Indique si les attributs personnalisés d’un type spécifié sont appliqués à un membre spécifié.