CallingConventions Énumération

Définition

Définit les conventions d’appel valides pour une méthode.Defines the valid calling conventions for a method.

Cette énumération a un attribut FlagsAttribute qui permet une combinaison au niveau du bit de ses valeurs membres.

public enum class CallingConventions
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum CallingConventions
type CallingConventions = 
Public Enum CallingConventions
Héritage
CallingConventions
Attributs

Champs

Any 3

Spécifie si la convention d'appel Standard ou VarArgs peut être utilisée.Specifies that either the Standard or the VarArgs calling convention may be used.

ExplicitThis 64

Spécifie que la signature est une signature de pointeur fonction, représentant un appel à une instance ou une méthode virtuelle (pas une méthode statique).Specifies that the signature is a function-pointer signature, representing a call to an instance or virtual method (not a static method). Si ExplicitThis est défini, HasThis doit aussi être défini.If ExplicitThis is set, HasThis must also be set. Le premier argument passé à la méthode appelée est toujours un pointeur this, mais le type du premier argument est désormais inconnu.The first argument passed to the called method is still a this pointer, but the type of the first argument is now unknown. Par conséquent, un jeton qui décrit le type (ou la classe) du pointeur this est explicitement stocké dans sa signature de métadonnées.Therefore, a token that describes the type (or class) of the this pointer is explicitly stored into its metadata signature.

HasThis 32

Spécifie une instance ou une méthode virtuelle (pas une méthode statique).Specifies an instance or virtual method (not a static method). Au moment de l'exécution, un pointeur vers l'objet cible est passé à la méthode appelée en tant que premier argument (le pointeur this).At run-time, the called method is passed a pointer to the target object as its first argument (the this pointer). La signature stockée dans les métadonnées n'inclut pas le type du premier argument, car la méthode est connue et sa classe propriétaire peut être découverte à partir des métadonnées.The signature stored in metadata does not include the type of this first argument, because the method is known and its owner class can be discovered from metadata.

Standard 1

Spécifie la convention d'appel par défaut telle que déterminée par le Common Language Runtime.Specifies the default calling convention as determined by the common language runtime. Utilisez cette convention d'appel pour les méthodes statiques.Use this calling convention for static methods. Pour les méthodes d'instance ou virtuelles, utilisez HasThis.For instance or virtual methods use HasThis.

VarArgs 2

Spécifie la convention d'appel pour les méthodes avec des arguments variables.Specifies the calling convention for methods with variable arguments.

Exemples

using namespace System;
using namespace System::Reflection;
using namespace System::Security;
public ref class MyClass1
{
public:
   MyClass1( int i ){}

};

int main()
{
   try
   {
      Type^ myType = MyClass1::typeid;
      array<Type^>^types = gcnew array<Type^>(1);
      types[ 0 ] = int::typeid;
      
      // Get the public instance constructor that takes an integer parameter.
      ConstructorInfo^ constructorInfoObj = myType->GetConstructor( static_cast<BindingFlags>(BindingFlags::Instance | BindingFlags::Public), nullptr, CallingConventions::HasThis, types, nullptr );
      if ( constructorInfoObj != nullptr )
      {
         Console::WriteLine( "The constructor of MyClass1 that is a public instance method and takes an integer as a parameter is: " );
         Console::WriteLine( constructorInfoObj );
      }
      else
      {
         Console::WriteLine( "The constructor of MyClass1 that is a public instance method and takes an integer as a parameter is not available." );
      }
   }
   catch ( ArgumentNullException^ e ) 
   {
      Console::WriteLine( "ArgumentNullException: {0}", e->Message );
   }
   catch ( ArgumentException^ e ) 
   {
      Console::WriteLine( "ArgumentException: {0}", e->Message );
   }
   catch ( SecurityException^ e ) 
   {
      Console::WriteLine( "SecurityException: {0}", e->Message );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}", e->Message );
   }
}
using System;
using System.Reflection;
using System.Security;

public class MyClass1
{
    public MyClass1(int i){}
    public static void Main()
    {
        try
        {
            Type  myType = typeof(MyClass1);
            Type[] types = new Type[1];
            types[0] = typeof(int);
            // Get the public instance constructor that takes an integer parameter.
            ConstructorInfo constructorInfoObj = myType.GetConstructor(
                BindingFlags.Instance | BindingFlags.Public, null,
                CallingConventions.HasThis, types, null);
            if(constructorInfoObj != null)
            {
                Console.WriteLine("The constructor of MyClass1 that is a public " +
                    "instance method and takes an integer as a parameter is: ");
                Console.WriteLine(constructorInfoObj.ToString());
            }
            else
            {
                Console.WriteLine("The constructor of MyClass1 that is a public instance " +
                    "method and takes an integer as a parameter is not available.");
            }
        }
        catch(ArgumentNullException e)
        {
            Console.WriteLine("ArgumentNullException: " + e.Message);
        }
        catch(ArgumentException e)
        {
            Console.WriteLine("ArgumentException: " + e.Message);
        }
        catch(SecurityException e)
        {
            Console.WriteLine("SecurityException: " + e.Message);
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception: " + e.Message);
        }
    }
}
Public Class MyClass1
    Public Sub New(ByVal i As Integer)
    End Sub
    Public Shared Sub Main()
        Try
            Dim myType As Type = GetType(MyClass1)
            Dim types(0) As Type
            types(0) = GetType(Integer)
            ' Get the public instance constructor that takes an integer parameter.
            Dim constructorInfoObj As ConstructorInfo = _
                        myType.GetConstructor(BindingFlags.Instance Or _
                        BindingFlags.Public, Nothing, _
                        CallingConventions.HasThis, types, Nothing)
            If Not (constructorInfoObj Is Nothing) Then
                Console.WriteLine("The constructor of MyClass1 that " + _
                                  "is a public instance method and takes an " + _
                                  "integer as a parameter is: ")
                Console.WriteLine(constructorInfoObj.ToString())
            Else
                Console.WriteLine("The constructor MyClass1 that " + _
                                  "is a public instance method and takes an " + _
                                  "integer as a parameter is not available.")
            End If
        Catch e As ArgumentNullException
            Console.WriteLine("ArgumentNullException: " + e.Message)
        Catch e As ArgumentException
            Console.WriteLine("ArgumentException: " + e.Message)
        Catch e As SecurityException
            Console.WriteLine("SecurityException: " + e.Message)
        Catch e As Exception
            Console.WriteLine("Exception: " + e.Message)
        End Try
    End Sub
End Class

Remarques

La Convention d’appel native est l’ensemble de règles régissant l’ordre et la disposition des arguments passés aux méthodes compilées.The native calling convention is the set of rules governing the order and layout of arguments passed to compiled methods. Elle régit également la manière de passer la valeur de retour, les registres à utiliser pour les arguments et si le appelé ou la méthode appelante supprime des arguments de la pile.It also governs how to pass the return value, what registers to use for arguments, and whether the called or the calling method removes arguments from the stack.

S’applique à