Esta página foi útil?
Seus comentários sobre este conteúdo são importantes. Queremos saber sua opinião.
Comentários adicionais?
1500 caracteres restantes
CallingConventions Enumeração
Collapse the table of content
Expand the table of content
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

CallingConventions Enumeração

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

Essa enumeração tem um atributo FlagsAttribute que permite uma combinação de seus valores membro bit a bit.

Namespace:  System.Reflection
Assembly:  mscorlib (em mscorlib. dll)

[SerializableAttribute]
[FlagsAttribute]
[ComVisibleAttribute(true)]
public enum CallingConventions

Nome do membroDescrição
StandardEspecifica o padrão chamada convenção, conforme determinado pelo Comummon Idioma Tempo de execução.Use esta convenção de chamada para métodos estáticos.For instance or virtual methods use HasThis.
VarArgsEspecifica a convenção de chamada para métodos com argumentos de variável.
AnySpecifies that either the Standard or the VarArgs calling convention may be used.
HasThisEspecifica uma instância ou método virtual (não um método estático).At run-time, the called method is passed a pointer to the target object as its first argument (the this pointer).A assinatura armazenada em metadados não inclui o tipo deste primeiro argumento, porque o método é conhecido e sua classe proprietário pode ser descoberta de metadados.
ExplicitThisEspecifica que a assinatura é uma assinatura de função-ponteiro, que representa uma chamada para uma instância ou método virtual (não um método estático).If ExplicitThis is set, HasThis must also be set.The first argument passed to the called method is still a this pointer, but the type of the first argument is now unknown.Therefore, a token that describes the type (or class) of the this pointer is explicitly stored into its metadata signature.

O Nativo chamado convenção é o conjunto de regras que determinam a ordem e layout de argumentos passados para compilado métodos.Ele também governa como passar o valor de retorno, que registra a ser usado para argumentos e se a chamada ou o método de chamada remove argumentos da pilha.

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);
        }
    }
}


import System.*;
import System.Reflection.*;
import System.Security.*;

public class MyClass1
{
    public MyClass1(int i)
    {
    } //MyClass1

    public static void main(String[] args)
    {
        try {
            Type myType = MyClass1.class.ToType();
            Type types[] = new Type[1];
            types.set_Item(0, int.class.ToType());
            // 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.get_Message());
        }
        catch (ArgumentException e) {
            Console.WriteLine("ArgumentException: " + e.get_Message());
        }
        catch (SecurityException e) {
            Console.WriteLine("SecurityException: " + e.get_Message());
        }
        catch (System.Exception e) {
            Console.WriteLine("Exception: " + e.get_Message());
        }
    } //main
} //MyClass1


Contribuições da comunidade

ADICIONAR
Mostrar:
© 2015 Microsoft