CallingConventions CallingConventions CallingConventions CallingConventions Enum

定義

定義方法的有效呼叫慣例 (Calling Convention)。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,也必須設定 HasThisIf 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 指標之型別 (或類別) 的語彙基元會明確地儲存到它的中繼資料 (Metadata) 簽章中。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

指定如同 Common Language Runtime 所判斷的預設呼叫慣例。Specifies the default calling convention as determined by the common language runtime. 靜態方法要使用此呼叫慣例。Use this calling convention for static methods. 若為執行個體或虛擬方法,則需使用 HasThisFor 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.

適用於