CallingConventions Enumeration

Definition

Definiert die gültigen Aufrufkonventionen für eine Methode.Defines the valid calling conventions for a method.

Diese Enumeration weist ein FlagsAttribute-Attribut auf, die eine bitweise Kombination der Memberwerte zulässt.

public enum class CallingConventions
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum CallingConventions
type CallingConventions = 
Public Enum CallingConventions
Vererbung
CallingConventions
Attribute

Felder

Any 3

Gibt an, dass entweder die Standard-Aufrufkonvention oder die VarArgs-Aufrufkonvention verwendet werden kann.Specifies that either the Standard or the VarArgs calling convention may be used.

ExplicitThis 64

Gibt an, dass es sich bei der Signatur um eine Funktionszeiger-Signatur handelt, die einen Aufruf einer Instanz oder einer virtuellen Methode (keiner statischen Methode) darstellt.Specifies that the signature is a function-pointer signature, representing a call to an instance or virtual method (not a static method). Wenn ExplicitThis festgelegt ist, muss HasThis ebenfalls festgelegt werden.If ExplicitThis is set, HasThis must also be set. Das erste an die aufgerufene Methode übergebene Argument ist weiterhin ein this-Zeiger, der Typ des ersten Arguments ist jedoch jetzt unbekannt.The first argument passed to the called method is still a this pointer, but the type of the first argument is now unknown. Deshalb wird ein Token, das den Typ (oder die Klasse) des this-Zeigers beschreibt, in der Signatur der Metadaten explizit gespeichert.Therefore, a token that describes the type (or class) of the this pointer is explicitly stored into its metadata signature.

HasThis 32

Gibt eine Instanz oder eine virtuelle Methode (keine statische Methode) an.Specifies an instance or virtual method (not a static method). Zur Laufzeit wird der aufgerufenen Methode als erstes Argument ein Zeiger auf das Zielobjekt übergeben (der this-Zeiger).At run-time, the called method is passed a pointer to the target object as its first argument (the this pointer). Die in den Metadaten gespeicherte Signatur enthält den Typ dieses ersten Arguments nicht, da die Methode bekannt ist und die Klasse, die diese besitzt, aus den Metadaten ermittelt werden kann.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

Gibt die Standardaufrufkonvention an, die durch die Common Language Runtime bestimmt wurde.Specifies the default calling convention as determined by the common language runtime. Verwenden Sie diese Aufrufkonvention für statische Methoden.Use this calling convention for static methods. Verwenden Sie HasThis für Instanzen oder virtuelle Methoden.For instance or virtual methods use HasThis.

VarArgs 2

Gibt die Aufrufkonvention für Methoden mit variablen Argumenten an.Specifies the calling convention for methods with variable arguments.

Beispiele

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

Hinweise

Die native Aufruf Konvention ist der Regelsatz, der die Reihenfolge und das Layout von Argumenten bestimmt, die an kompilierte Methoden übermittelt werden.The native calling convention is the set of rules governing the order and layout of arguments passed to compiled methods. Außerdem wird gesteuert, wie der Rückgabewert übergeben wird, welche Register für Argumente verwendet werden sollen und ob die aufgerufene oder die Aufruf Methode Argumente aus dem Stapel entfernt.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.

Gilt für: