MethodBuilder Classe

Définition

Définit et représente une méthode (ou un constructeur) sur une classe dynamique.Defines and represents a method (or constructor) on a dynamic class.

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
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder
Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder
Héritage
Attributs
Implémente

Exemples

L’exemple suivant utilise la classe MethodBuilder pour créer une méthode dans un type dynamique.The following example uses the MethodBuilder class to create a method within a dynamic type.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void AddMethodDynamically( TypeBuilder^ myTypeBld, 
                           String^ mthdName, 
                           array<Type^>^ mthdParams, 
                           Type^ returnType, 
                           String^ mthdAction )
{
   MethodBuilder^ myMthdBld = myTypeBld->DefineMethod( mthdName, static_cast<MethodAttributes>(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++ )
      {
         if ( mthdAction->Equals( "A" ) )
                  ILOut->Emit( OpCodes::Add );
         else
         if ( mthdAction->Equals( "M" ) )
                  ILOut->Emit( OpCodes::Mul );
         else
                  ILOut->Emit( OpCodes::Add );

      }
   }

   ILOut->Emit( OpCodes::Ret );
};

void main()
{
   AppDomain^ myDomain = AppDomain::CurrentDomain;
   AssemblyName^ asmName = gcnew 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;
   array<String^>^inputNumsList = inputNums->Split();
   array<Type^>^myMthdParams = gcnew array<Type^>(inputNumsList->Length);
   array<Object^>^inputValsList = gcnew array<Object^>(inputNumsList->Length);
   for each (String^ inputNum in inputNumsList)
   {
      inputValsList[ index ] = Convert::ToInt32( inputNum );
      myMthdParams[ index ] = int::typeid;
      index++;
   }

   
   // Now, call the method building method with the parameters, passing the
   // TypeBuilder by reference.
   AddMethodDynamically( myTypeBld, 
                         myMthdName, 
                         myMthdParams, 
                         int::typeid, 
                         myMthdAction );
   Type^ myType = myTypeBld->CreateType();

   Console::WriteLine( "---" );
   Console::WriteLine( "The result of {0} the inputted values is: {1}", 
                       ((myMthdAction->Equals( "M" )) ? "multiplying" : "adding"), 
                       myType->InvokeMember( myMthdName, 
                                             BindingFlags::InvokeMethod | BindingFlags::Public | BindingFlags::Static, 
                       nullptr, 
                       nullptr, 
                       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 );
}


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

La classe MethodBuilder est utilisée pour décrire entièrement une méthode en langage MSIL (Microsoft Intermediate Language), notamment le nom, les attributs, la signature et le corps de la méthode.The MethodBuilder class is used to fully describe a method in Microsoft intermediate language (MSIL), including the name, attributes, signature, and method body. Elle est utilisée conjointement avec la classe TypeBuilder pour créer des classes au moment de l’exécution.It is used in conjunction with the TypeBuilder class to create classes at runtime.

Méthodes et méthodes globales en tant que membres de typeGlobal methods and methods as type members

Vous pouvez utiliser l’émission de réflexion pour définir des méthodes globales et définir des méthodes en tant que membres de type.You can use reflection emit to define global methods and to define methods as type members. Les API qui définissent les méthodes retournent des objets MethodBuilder.The APIs that define methods return MethodBuilder objects.

Méthodes globalesGlobal methods

Une méthode globale est définie à l’aide de la méthode ModuleBuilder.DefineGlobalMethod, qui retourne un objet MethodBuilder .A global method is defined by using the ModuleBuilder.DefineGlobalMethod method, which returns a MethodBuilder object.

Les méthodes globales doivent être statiques.Global methods must be static. Si un module dynamique contient des méthodes globales, la méthode ModuleBuilder.CreateGlobalFunctions doit être appelée avant la persistance du module dynamique ou de l’assembly dynamique conteneur, car le common language runtime diffère la correction du module dynamique jusqu’à ce que toutes les fonctions globales aient été définies.If a dynamic module contains global methods, the ModuleBuilder.CreateGlobalFunctions method must be called before persisting the dynamic module or the containing dynamic assembly because the common language runtime postpones fixing up the dynamic module until all global functions have been defined.

Une méthode Native globale est définie à l’aide de la méthode ModuleBuilder.DefinePInvokeMethod.A global native method is defined by using the ModuleBuilder.DefinePInvokeMethod method. Les méthodes d’appel de code non managé (PInvoke) ne doivent pas être déclarées abstract ou Virtual.Platform invoke (PInvoke) methods must not be declared abstract or virtual. Le runtime définit l’attribut MethodAttributes.PinvokeImpl pour une méthode d’appel de code non managé.The runtime sets the MethodAttributes.PinvokeImpl attribute for a platform invoke method.

Méthodes en tant que membres de typesMethods as members of types

Une méthode est définie en tant que membre de type à l’aide de la méthode TypeBuilder.DefineMethod, qui retourne un objet MethodBuilder.A method is defined as a type member by using the TypeBuilder.DefineMethod method, which returns a MethodBuilder object.

La méthode DefineParameter est utilisée pour définir les attributs de nom et de paramètre d’un paramètre, ou de la valeur de retour.The DefineParameter method is used to set the name and parameter attributes of a parameter, or of the return value. L’objet ParameterBuilder retourné par cette méthode représente un paramètre ou la valeur de retour.The ParameterBuilder object returned by this method represents a parameter or the return value. L’objet ParameterBuilder peut être utilisé pour définir le marshaling, pour définir la valeur de constante et pour appliquer des attributs personnalisés.The ParameterBuilder object can be used to set the marshaling, to set the constant value, and to apply custom attributes.

AttributsAttributes

Les membres de l’énumération MethodAttributes définissent le caractère précis d’une méthode dynamique :Members of the MethodAttributes enumeration define the precise character of a dynamic method:

Problèmes connusKnown Issues

Propriétés

Attributes

Récupère les attributs de cette méthode.Retrieves the attributes for this method.

CallingConvention

Retourne la convention d'appel de la méthode.Returns the calling convention of the method.

ContainsGenericParameters

Non pris en charge pour ce type.Not supported for this type.

CustomAttributes

Obtient une collection qui contient les attributs personnalisés de ce membre.Gets a collection that contains this member's custom attributes.

(Hérité de MemberInfo)
DeclaringType

Retourne le type qui déclare cette méthode.Returns the type that declares this method.

InitLocals

Obtient ou définit une valeur Boolean qui indique si les variables locales contenues dans cette méthode sont initialisées à zéro.Gets or sets a Boolean value that specifies whether the local variables in this method are zero initialized. La valeur par défaut de cette propriété est true.The default value of this property is true.

IsAbstract

Obtient une valeur indiquant si la méthode est abstraite.Gets a value indicating whether the method is abstract.

(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, c'est-à-dire si la méthode ou le constructeur 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.Gets a value indicating whether the potential visibility of this method or constructor is described by Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

(Hérité de MethodBase)
IsCollectible

Obtient une valeur qui indique si cet objet MemberInfo fait partie d’un assembly contenu dans un AssemblyLoadContext pouvant être collecté.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Hérité de MemberInfo)
IsConstructedGenericMethod
IsConstructor

Obtient une valeur indiquant si la méthode est un constructeur.Gets a value indicating whether the method is a constructor.

(Hérité de MethodBase)
IsFamily

Obtient une valeur indiquant si la visibilité de cette méthode ou de ce constructeur est décrite par Family, c'est-à-dire si la méthode ou le constructeur est visible uniquement dans sa classe et dans ses classes dérivées.Gets a value indicating whether the visibility of this method or constructor is described by Family; that is, the method or constructor is visible only within its class and derived classes.

(Hérité de MethodBase)
IsFamilyAndAssembly

Obtient une valeur indiquant si la visibilité de cette méthode ou de ce constructeur est décrite par FamANDAssem, c'est-à-dire si la méthode ou le constructeur peut être appelé par des classes dérivées, mais uniquement si elles se trouvent dans le même assembly.Gets a value indicating whether the visibility of this method or constructor is described by FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same 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, c'est-à-dire si la méthode ou le constructeur peut être appelé par des classes dérivées où qu'elles se trouvent, et par des classes du même assembly.Gets a value indicating whether the potential visibility of this method or constructor is described by FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

(Hérité de MethodBase)
IsFinal

Obtient une valeur indiquant si cette méthode est final.Gets a value indicating whether this method is final.

(Hérité de MethodBase)
IsGenericMethod

Obtient une valeur indiquant si la méthode est une méthode générique.Gets a value indicating whether the method is a generic method.

IsGenericMethodDefinition

Obtient une valeur qui indique si l'objet MethodBuilder actuel représente la définition d'une méthode générique.Gets a value indicating whether the current MethodBuilder object represents the definition of a generic method.

IsHideBySig

Obtient une valeur indiquant si seul un membre du même type, doté d'une signature identique, est caché dans la classe dérivée.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(Hérité de MethodBase)
IsPrivate

Obtient une valeur indiquant si ce membre est privé.Gets a value indicating whether this member is private.

(Hérité de MethodBase)
IsPublic

Obtient une valeur indiquant s'il s'agit d'une méthode publique.Gets a value indicating whether this is a public method.

(Hérité de MethodBase)
IsSecurityCritical

Lève une exception NotSupportedException dans tous les cas.Throws a NotSupportedException in all cases.

IsSecuritySafeCritical

Lève une exception NotSupportedException dans tous les cas.Throws a NotSupportedException in all cases.

IsSecurityTransparent

Lève une exception NotSupportedException dans tous les cas.Throws a NotSupportedException in all cases.

IsSpecialName

Obtient une valeur indiquant si cette méthode est dotée d'un nom spécial.Gets a value indicating whether this method has a special name.

(Hérité de MethodBase)
IsStatic

Obtient une valeur indiquant si la méthode est static.Gets a value indicating whether the method is static.

(Hérité de MethodBase)
IsVirtual

Obtient une valeur indiquant si la méthode est virtual.Gets a value indicating whether the method is virtual.

(Hérité de MethodBase)
MemberType

Obtient une MemberTypes valeur indiquant que ce membre est une méthode.Gets a MemberTypes value indicating that this member is a method.

(Hérité de MethodInfo)
MetadataToken

Obtient une valeur qui identifie un élément de métadonnées.Gets a value that identifies a metadata element.

(Hérité de MemberInfo)
MethodHandle

Récupère le handle interne de la méthode.Retrieves the internal handle for the method. Utilisez ce handle pour accéder au handle des métadonnées sous-jacentes.Use this handle to access the underlying metadata handle.

MethodImplementationFlags
Module

Obtient le module dans lequel la méthode actuelle est définie.Gets the module in which the current method is being defined.

Name

Récupère le nom de cette méthode.Retrieves the name of this method.

ReflectedType

Récupère la classe dont la réflexion a été utilisée pour obtenir cet objet.Retrieves the class that was used in reflection to obtain this object.

ReturnParameter

Obtient un objet ParameterInfo qui contient des informations relatives au type de retour de la méthode, telles que la présence de modificateurs personnalisés.Gets a ParameterInfo object that contains information about the return type of the method, such as whether the return type has custom modifiers.

ReturnType

Obtient le type de retour de la méthode représentée par ce MethodBuilder.Gets the return type of the method represented by this MethodBuilder.

ReturnTypeCustomAttributes

Retourne les attributs personnalisés du type de retour de la méthode.Returns the custom attributes of the method's return type.

Signature

Récupère la signature de la méthode.Retrieves the signature of the method.

Méthodes

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Ajoute la sécurité déclarative à cette méthode.Adds declarative security to this method.

CreateDelegate(Type)

Crée un délégué du type spécifié à partir de cette méthode.Creates a delegate of the specified type from this method.

(Hérité de MethodInfo)
CreateDelegate(Type, Object)

Crée un délégué du type spécifié avec la cible spécifiée à partir de cette méthode.Creates a delegate of the specified type with the specified target from this method.

(Hérité de MethodInfo)
CreateMethodBody(Byte[], Int32)

Crée le corps de la méthode en utilisant un tableau d’octets d’instructions MSIL (Microsoft Intermediate Language) spécifié.Creates the body of the method using a supplied byte array of Microsoft intermediate language (MSIL) instructions.

DefineGenericParameters(String[])

Définit le nombre de paramètres de type générique pour la méthode actuelle, indique leurs noms et retourne un tableau d'objets GenericTypeParameterBuilder qui peuvent être utilisés pour définir leurs contraintes.Sets the number of generic type parameters for the current method, specifies their names, and returns an array of GenericTypeParameterBuilder objects that can be used to define their constraints.

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.Sets the parameter attributes and the name of a parameter of this method, or of the return value of this method. Retourne un ParameterBuilder qui peut être utilisé pour appliquer des attributs personnalisés.Returns a ParameterBuilder that can be used to apply custom attributes.

Equals(Object)

Détermine si l'objet donné est égal à cette instance.Determines whether the given object is equal to this instance.

GetBaseDefinition()

Retourne l’implémentation de base pour une méthode.Return the base implementation for a method.

GetCustomAttributes(Boolean)

Retourne tous les attributs personnalisés définis pour cette méthode.Returns all the custom attributes defined for this method.

GetCustomAttributes(Type, Boolean)

Retourne les attributs personnalisés identifiés par le type donné.Returns the custom attributes identified by the given type.

GetCustomAttributesData()

Renvoie une liste d’objets CustomAttributeData représentant des données sur les attributs qui ont été appliqués au membre cible.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Hérité de MemberInfo)
GetGenericArguments()

Retourne un tableau d'objets GenericTypeParameterBuilder qui représentent les paramètres de type de la méthode, si elle est générique.Returns an array of GenericTypeParameterBuilder objects that represent the type parameters of the method, if it is generic.

GetGenericMethodDefinition()

Retourne cette méthode.Returns this method.

GetHashCode()

Obtient le code de hachage de cette méthode.Gets the hash code for this method.

GetILGenerator()

Retourne ILGenerator pour cette méthode avec une taille de flux MSIL (Microsoft Intermediate Language) par défaut de 64 octets.Returns an ILGenerator for this method with a default Microsoft intermediate language (MSIL) stream size of 64 bytes.

GetILGenerator(Int32)

Retourne un ILGenerator pour cette méthode avec la taille de flux MSIL (Microsoft Intermediate Language) spécifiée.Returns an ILGenerator for this method with the specified Microsoft intermediate language (MSIL) stream size.

GetMethodBody()

En cas de substitution dans une classe dérivée, obtient un objet MethodBody qui donne accès au flux MSIL, aux variables locales et aux exceptions pour la méthode actuelle.When overridden in a derived class, gets a MethodBody object that provides access to the MSIL stream, local variables, and exceptions for the current method.

(Hérité de MethodBase)
GetMethodImplementationFlags()

Retourne les indicateurs d'implémentation de la méthode.Returns the implementation flags for the method.

GetModule()

Retourne une référence au module qui contient cette méthode.Returns a reference to the module that contains this method.

GetParameters()

Retourne les paramètres de cette méthode.Returns the parameters of this method.

GetToken()

Retourne le MethodToken représentant le jeton de cette méthode.Returns the MethodToken that represents the token for this method.

GetType() (Hérité de MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Hérité de MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Appelle le constructeur réfléchi de manière dynamique par cette instance sur l'objet donné, et passe les paramètres spécifiés, avec les contraintes du binder donné.Dynamically invokes the method reflected by this instance on the given object, passing along the specified parameters, and under the constraints of the given binder.

Invoke(Object, Object[]) (Hérité de MethodInfo)
IsDefined(Type, Boolean)

Vérifie si le type d’attribut personnalisé spécifié est défini.Checks if the specified custom attribute type is defined.

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.Returns a generic method constructed from the current generic method definition using the specified generic type arguments.

MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Définit un attribut personnalisé à l’aide d’un objet blob d’attribut personnalisé spécifié.Sets a custom attribute using a specified custom attribute blob.

SetCustomAttribute(CustomAttributeBuilder)

Définit un attribut personnalisé à l’aide d’un générateur d’attributs personnalisés.Sets a custom attribute using a custom attribute builder.

SetImplementationFlags(MethodImplAttributes)

Définit les indicateurs d’implémentation de cette méthode.Sets the implementation flags for this method.

SetMarshal(UnmanagedMarshal)

Définit les informations de marshaling pour le type de retour de cette méthode.Sets marshaling information for the return type of this method.

SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)

Crée le corps de la méthode à l'aide d'un tableau d'octets d'instructions MSIL (Microsoft Intermediate Language) spécifié.Creates the body of the method by using a specified byte array of Microsoft intermediate language (MSIL) instructions.

SetParameters(Type[])

Définit le nombre et les types des paramètres d’une méthode.Sets the number and types of parameters for a method.

SetReturnType(Type)

Définit le type de retour de la méthode.Sets the return type of the method.

SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])

Définit la signature de la méthode, y compris le type de retour, les types de paramètres, ainsi que les modificateurs personnalisés requis et facultatifs du type de retour et des types de paramètres.Sets the method signature, including the return type, the parameter types, and the required and optional custom modifiers of the return type and parameter types.

SetSymCustomAttribute(String, Byte[])

Définissez un attribut personnalisé symbolique à l’aide d’un objet blob.Set a symbolic custom attribute using a blob.

ToString()

Retourne cette instance de MethodBuilder en tant que chaîne.Returns this MethodBuilder instance as a string.

Implémentations d’interfaces explicites

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de MemberInfo)
_MemberInfo.GetType()

Obtient un objet Type représentant la classe MemberInfo.Gets a Type object representing the MemberInfo class.

(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.Retrieves the type information for an object, which can then be used to get the type information for an 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).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de MethodBase)
_MethodBase.GetType()

Pour obtenir une description de ce membre, consultez GetType().For a description of this member, see 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.Retrieves the type information for an object, which can then be used to get the type information for an 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).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de MethodBase)
_MethodBase.IsAbstract

Pour obtenir une description de ce membre, consultez IsAbstract.For a description of this member, see IsAbstract.

(Hérité de MethodBase)
_MethodBase.IsAssembly

Pour obtenir une description de ce membre, consultez IsAssembly.For a description of this member, see IsAssembly.

(Hérité de MethodBase)
_MethodBase.IsConstructor

Pour obtenir une description de ce membre, consultez IsConstructor.For a description of this member, see IsConstructor.

(Hérité de MethodBase)
_MethodBase.IsFamily

Pour obtenir une description de ce membre, consultez IsFamily.For a description of this member, see IsFamily.

(Hérité de MethodBase)
_MethodBase.IsFamilyAndAssembly

Pour obtenir une description de ce membre, consultez IsFamilyAndAssembly.For a description of this member, see IsFamilyAndAssembly.

(Hérité de MethodBase)
_MethodBase.IsFamilyOrAssembly

Pour obtenir une description de ce membre, consultez IsFamilyOrAssembly.For a description of this member, see IsFamilyOrAssembly.

(Hérité de MethodBase)
_MethodBase.IsFinal

Pour obtenir une description de ce membre, consultez IsFinal.For a description of this member, see IsFinal.

(Hérité de MethodBase)
_MethodBase.IsHideBySig

Pour obtenir une description de ce membre, consultez IsHideBySig.For a description of this member, see IsHideBySig.

(Hérité de MethodBase)
_MethodBase.IsPrivate

Pour obtenir une description de ce membre, consultez IsPrivate.For a description of this member, see IsPrivate.

(Hérité de MethodBase)
_MethodBase.IsPublic

Pour obtenir une description de ce membre, consultez IsPublic.For a description of this member, see IsPublic.

(Hérité de MethodBase)
_MethodBase.IsSpecialName

Pour obtenir une description de ce membre, consultez IsSpecialName.For a description of this member, see IsSpecialName.

(Hérité de MethodBase)
_MethodBase.IsStatic

Pour obtenir une description de ce membre, consultez IsStatic.For a description of this member, see IsStatic.

(Hérité de MethodBase)
_MethodBase.IsVirtual

Pour obtenir une description de ce membre, consultez IsVirtual.For a description of this member, see 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.Maps a set of names to a corresponding set of dispatch identifiers.

_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.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_MethodBuilder.GetTypeInfoCount(UInt32)

Récupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

_MethodBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Hérité de MethodInfo)
_MethodInfo.GetType()

Fournit l'accès à la méthode GetType() à partir de COM.Provides access to the GetType() method from COM.

(Hérité de MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Récupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface.Retrieves the type information for an object, which can be used to get the type information for an 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).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Hérité de MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fournit l'accès aux propriétés et aux méthodes exposées par un objet.Provides access to properties and methods exposed by an object.

(Hérité de MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean) (Hérité de MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) (Hérité de MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean) (Hérité de MemberInfo)

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é.Retrieves a custom attribute of a specified type that is applied to a specified member.

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.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

Récupère un attribut personnalisé d'un type spécifié qui est appliqué à un membre spécifié.Retrieves a custom attribute of a specified type that is applied to a specified member.

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.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

Récupère une collection d'attributs personnalisés qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes that are applied to a specified member.

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.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

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.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

Extrait une collection d'attributs personnalisés d'un type spécifié qui sont appliqués à un membre spécifié.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

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.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

Indique si des attributs personnalisés d'un type spécifié sont appliqués à un membre spécifié.Indicates whether custom attributes of a specified type are applied to a specified member.

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.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

Obtient un jeton de métadonnées pour le membre donné, s’il est disponible.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Retourne une valeur qui indique si un jeton de métadonnées est disponible pour le membre spécifié.Returns a value that indicates whether a metadata token is available for the specified member.

GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo)

Récupère un objet qui représente la méthode spécifiée dans la classe de base directe ou indirecte où la méthode a été déclarée la première fois.Retrieves an object that represents the specified method on the direct or indirect base class where the method was first declared.

S’applique à