CallingConventions CallingConventions CallingConventions CallingConventions Enum

Определение

Определяет допустимые соглашения вызова для метода.Defines the valid calling conventions for a method.

Это перечисление имеет атрибут FlagsAttribute, который разрешает побитовое сочетание значений его элементов.

public enum class CallingConventions
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum CallingConventions
type CallingConventions = 
Public Enum CallingConventions
Наследование
CallingConventionsCallingConventionsCallingConventionsCallingConventions
Атрибуты

Поля

Any Any Any Any 3

Определяет используемые соглашения вызова: Standard или VarArgs.Specifies that either the Standard or the VarArgs calling convention may be used.

ExplicitThis ExplicitThis ExplicitThis ExplicitThis 64

Указывает, что данная сигнатура является сигнатурой указателя функции, представляя собой экземпляр или виртуальный (не статический) метод.Specifies that the signature is a function-pointer signature, representing a call to an instance or virtual method (not a static method). Если установлен параметр ExplicitThis, должен быть задан и параметр HasThis.If ExplicitThis is set, HasThis must also be set. Первый аргумент, передаваемый вызываемому методу, все же является указателем this, но тип первого аргумента в этот момент неизвестен.The first argument passed to the called method is still a this pointer, but the type of the first argument is now unknown. Следовательно, в сигнатуре метаданных указателя this явно хранится маркер, описывающий тип (или класс) этого указателя.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

Определяет экземпляр или виртуальный (не статический) метод.Specifies an instance or virtual method (not a static method). Во время выполнения вызываемому методу в качестве первого аргумента передается указатель на конечный объект (указатель this).At run-time, the called method is passed a pointer to the target object as its first argument (the this pointer). Сигнатура, хранящаяся в метаданных, не содержит тип этого первого аргумента, так как этот метод известен и класс его владельца может быть извлечен из метаданных.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

Определяет соглашение вызова по умолчанию, определяемое общеязыковой средой выполнения.Specifies the default calling convention as determined by the common language runtime. Это соглашение о вызове используется для статических методов.Use this calling convention for static methods. Для экземпляра или виртуальных методов используется метод HasThis.For instance or virtual methods use HasThis.

VarArgs VarArgs VarArgs VarArgs 2

Определяет соглашение вызова для методов с переменными аргументами.Specifies the calling convention for methods with variable arguments.

Примеры

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

Комментарии

Соглашение о машинном вызове — это набор правил, регулирующих порядок и компоновку аргументов, передаваемых скомпилированным методам.The native calling convention is the set of rules governing the order and layout of arguments passed to compiled methods. Он также определяет, как передавать возвращаемое значение, какие регистры использовать для аргументов, а также вызываемый или вызывающий метод удаляет аргументы из стека.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.

Применяется к