CallingConventions Enumeração

Definição

Espaço de Nomes:
System.Reflection
Assemblagens:
mscorlib.dll, System.Reflection.Primitives.dll
Assemblagem:
mscorlib.dll
Assemblagem:
System.Reflection.Primitives.dll
Assemblagem:
netstandard.dll

Define as convenções válidas de chamada para um método.

Esta enumeração suporta uma combinação bit-a-bit dos respetivos valores membro.

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
Herança
Object
ValueType
Enum
CallingConventions
Atributos
FlagsAttribute SerializableAttribute ComVisibleAttribute

Campos

Name Valor Description
Standard 1

Especifica a convenção de chamada por defeito determinada pelo runtime da linguagem comum. Use esta convenção de chamadas para métodos estáticos. Por exemplo, ou métodos virtuais usam HasThis.
VarArgs 2

Especifica a convenção de chamada para métodos com argumentos variáveis.
Any 3

Especifica que pode ser usada ou Standard a VarArgs convenção de chamada.
HasThis 32

Especifica uma instância ou método virtual (não um método estático). Em tempo de execução, o método chamado recebe um ponteiro para o objeto alvo como seu primeiro argumento (o this ponteiro). A assinatura armazenada nos metadados não inclui o tipo deste primeiro argumento, porque o método é conhecido e a sua classe proprietária pode ser descoberta a partir dos metadados.
ExplicitThis 64

Especifica que a assinatura é uma assinatura de apontador de função, representando uma chamada a uma instância ou método virtual (não um método estático). Se ExplicitThis for definido, HasThis também deve ser definido. O primeiro argumento passado ao método chamado continua a ser um this apontador, mas o tipo do primeiro argumento é agora desconhecido. Assim, um token que descreve o tipo (ou classe) do this ponteiro é explicitamente armazenado na sua assinatura de metadados.

Exemplos

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

Observações

A convenção nativa de chamadas é o conjunto de regras que regem a ordem e a disposição dos argumentos passados aos métodos compilados. Também determina como passar o valor de retorno, que registos usar para argumentos e se o método chamado ou o método de chamada remove argumentos da pilha.

Aplica-se a