CallingConventions Enumerazione

Definizione

Spazio dei nomi:

System.Reflection

Assembly:

System.Runtime.dll

Definisce le convenzioni di chiamata valide per un metodo.

Questa enumerazione supporta una combinazione bit per bit dei rispettivi valori dei membri.

public enum class CallingConventions

[System.Flags]
public enum CallingConventions

[<System.Flags>]
type CallingConventions = 

Public Enum CallingConventions

Ereditarietà

Object

ValueType

Enum

CallingConventions

Attributi

FlagsAttribute

Campi

Any	3	Specifica che può essere utilizzata la convenzione di chiamata Standard o VarArgs.
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. Se si imposta ExplicitThis, è necessario impostare anche HasThis. Il primo argomento passato al metodo chiamato è ancora un puntatore this, ma il tipo del primo argomento è ora sconosciuto. Pertanto, un token che descrive il tipo, o classe, del puntatore this viene memorizzato in modo esplicito nella relativa firma dei metadati.
HasThis	32	Specifica un'istanza o un metodo virtuale, non statico. In fase di esecuzione, al metodo chiamato viene passato un puntatore all'oggetto di destinazione come primo argomento (puntatore this). 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.
Standard	1	Specifica la convenzione di chiamata predefinita così come determinato da Common Language Runtime. Utilizzare questa convenzione di chiamata per i metodi statici. Per metodi di istanza o virtuali utilizzare HasThis.
VarArgs	2	Specifica la convenzione di chiamata per i metodi con argomenti variabili.

Esempio

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 MyClass3
{
    public MyClass3(int i) { }
    public static void Main()
    {
        try
        {
            Type myType = typeof(MyClass3);
            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 MyClass3 that is a public " +
                    "instance method and takes an integer as a parameter is: ");
                Console.WriteLine(constructorInfoObj.ToString());
            }
            else
            {
                Console.WriteLine("The constructor of MyClass3 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 regolano l'ordine e il layout degli argomenti passati ai metodi compilati. Determina anche come passare il valore restituito, i registri da usare per gli argomenti e se il metodo chiamato o chiamante rimuove gli argomenti dallo stack.