CallingConventions Wyliczenie

Definicja

Przestrzeń nazw:

System.Reflection

Zestaw:

System.Reflection.Primitives.dll

Zestaw:

System.Runtime.dll

Zestaw:

mscorlib.dll

Zestaw:

netstandard.dll

Definiuje prawidłowe konwencje wywoływania dla metody.

To wyliczenie obsługuje bitową kombinację jego wartości składowych.

public enum class CallingConventions

[System.Flags]
public enum CallingConventions

[System.Flags]
[System.Serializable]
public enum CallingConventions

[System.Flags]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum CallingConventions

[<System.Flags>]
type CallingConventions = 

[<System.Flags>]
[<System.Serializable>]
type CallingConventions = 

[<System.Flags>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CallingConventions = 

Public Enum CallingConventions

Dziedziczenie

Object

ValueType

Enum

CallingConventions

Atrybuty

FlagsAttribute SerializableAttribute ComVisibleAttribute

Pola

Any	3	Określa, że Standard może być używana konwencja wywoływania lub VarArgs .
ExplicitThis	64	Określa, że podpis jest podpisem wskaźnika funkcji, reprezentującym wywołanie wystąpienia lub metody wirtualnej (a nie metody statycznej). Jeśli ExplicitThis jest ustawiona, HasThis należy również ustawić. Pierwszy argument przekazany do wywołanej metody jest nadal wskaźnikiem this , ale typ pierwszego argumentu jest teraz nieznany. W związku z tym token opisujący typ (lub klasę) this wskaźnika jest jawnie przechowywany w podpisie metadanych.
HasThis	32	Określa wystąpienie lub metodę wirtualną (nie metodę statyczną). W czasie wykonywania wywołana metoda jest przekazywana wskaźnik do obiektu docelowego jako pierwszy argument ( this wskaźnik). Podpis przechowywany w metadanych nie zawiera typu tego pierwszego argumentu, ponieważ metoda jest znana, a jej klasa właściciela może zostać odnaleziona z metadanych.
Standard	1	Określa domyślną konwencję wywoływania określoną przez środowisko uruchomieniowe języka wspólnego. Użyj tej konwencji wywoływania dla metod statycznych. Na przykład lub metody wirtualne używają metody HasThis.
VarArgs	2	Określa konwencję wywoływania metod ze zmiennymi argumentami.

Przykłady

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

Uwagi

Natywna konwencja wywoływania to zestaw reguł rządzących kolejnością i układem argumentów przekazywanych do skompilowanych metod. Określa również, jak przekazać wartość zwracaną, jakie rejestry mają być używane dla argumentów oraz czy wywołana metoda wywołująca usuwa argumenty ze stosu.