CallingConventions CallingConventions CallingConventions CallingConventions Enum

Definizione

Definisce le convenzioni di chiamata valide per un metodo.Defines the valid calling conventions for a method.

Questa enumerazione ha un attributo FlagsAttribute che consente una combinazione bit per bit dei valori del relativo membro.

public enum class CallingConventions
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum CallingConventions
type CallingConventions = 
Public Enum CallingConventions
Ereditarietà
CallingConventionsCallingConventionsCallingConventionsCallingConventions
Attributi

Campi

Any Any Any Any 3

Specifica che può essere utilizzata la convenzione di chiamata Standard o VarArgs.Specifies that either the Standard or the VarArgs calling convention may be used.

ExplicitThis ExplicitThis ExplicitThis ExplicitThis 64

Specifica che la firma è di tipo puntatore a funzione e rappresenta una chiamata a un'istanza o a un metodo virtuale, non statico.Specifies that the signature is a function-pointer signature, representing a call to an instance or virtual method (not a static method). Se si imposta ExplicitThis, è necessario impostare anche HasThis.If ExplicitThis is set, HasThis must also be set. Il primo argomento passato al metodo chiamato è ancora un puntatore this, ma il tipo del primo argomento è ora sconosciuto.The first argument passed to the called method is still a this pointer, but the type of the first argument is now unknown. Pertanto, un token che descrive il tipo, o classe, del puntatore this viene memorizzato in modo esplicito nella relativa firma dei metadati.Therefore, a token that describes the type (or class) of the this pointer is explicitly stored into its metadata signature.

HasThis HasThis HasThis HasThis 32

Specifica un'istanza o un metodo virtuale, non statico.Specifies an instance or virtual method (not a static method). In fase di esecuzione, al metodo chiamato viene passato un puntatore all'oggetto di destinazione come primo argomento (puntatore this).At run-time, the called method is passed a pointer to the target object as its first argument (the this pointer). La firma memorizzata nei metadati non include il tipo di questo primo argomento, poiché il metodo è conosciuto e la classe proprietaria può essere individuata dai metadati.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 Standard Standard Standard 1

Specifica la convenzione di chiamata predefinita così come determinato da Common Language Runtime.Specifies the default calling convention as determined by the common language runtime. Utilizzare questa convenzione di chiamata per i metodi statici.Use this calling convention for static methods. Per metodi di istanza o virtuali utilizzare HasThis.For instance or virtual methods use HasThis.

VarArgs VarArgs VarArgs VarArgs 2

Specifica la convenzione di chiamata per i metodi con argomenti variabili.Specifies the calling convention for methods with variable arguments.

Esempi

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

Commenti

La convenzione di chiamata nativa è il set di regole che controllano l'ordine e il layout degli argomenti passati a metodi compilati.The native calling convention is the set of rules governing the order and layout of arguments passed to compiled methods. Inoltre determina come passare il valore restituito, quali registri da usare per gli argomenti e indica se la chiamata o il metodo di chiamata rimuove gli argomenti dallo stack.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.

Si applica a