CallingConventions Enumeração

Definição

Namespace:
System.Reflection
Assemblies:
mscorlib.dll, System.Reflection.Primitives.dll
Assembly:
mscorlib.dll
Assembly:
System.Reflection.Primitives.dll
Assembly:
netstandard.dll

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

Essa enumeração dá suporte a uma combinação bit a bit dos valores de 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

Nome Valor Description
Standard 1

Especifica a convenção de chamada padrão, conforme determinado pelo common language runtime. Use essa convenção de chamada 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 a convenção de chamada ou VarArgs de Standard chamada pode ser usada.
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 é passado um ponteiro para o objeto de destino como seu primeiro argumento (o this ponteiro). A assinatura armazenada em metadados não inclui o tipo desse primeiro argumento, pois o método é conhecido e sua classe de proprietário pode ser descoberta a partir de metadados.
ExplicitThis 64

Especifica que a assinatura é uma assinatura de ponteiro de função, representando uma chamada para uma instância ou método virtual (não um método estático). Se ExplicitThis estiver definido, HasThis também deverá ser definido. O primeiro argumento passado para o método chamado ainda é um this ponteiro, mas o tipo do primeiro argumento agora é desconhecido. Portanto, um token que descreve o tipo (ou classe) do this ponteiro é explicitamente armazenado em 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

Comentários

A convenção de chamada nativa é o conjunto de regras que regem a ordem e o layout dos argumentos passados para métodos compilados. Ele também rege como passar o valor retornado, o que se registra para usar para argumentos e se o método chamado ou de chamada remove argumentos da pilha.

Aplica-se a