CallingConventions Enumeración

Definición

Espacio de nombres:

System.Reflection

Ensamblado:

System.Runtime.dll

Define las convenciones de llamada válidas para un método.

Esta enumeración admite una combinación bit a bit de sus valores de miembro.

C#

[System.Flags]
public enum CallingConventions

Herencia

Object

ValueType

Enum

CallingConventions

Atributos

FlagsAttribute

Campos

Nombre	Valor	Description
Any	3	Especifica que puede utilizarse la convención de llamada Standard o VarArgs.
ExplicitThis	64	Especifica que la firma es una firma de puntero de función, que representa una llamada a una instancia o un método virtual (no un método estático). Si se establece ExplicitThis, también se debe especificar HasThis. El primer argumento pasado al método llamado sigue siendo un puntero this, pero el tipo del primer argumento ahora es desconocido. Por ello, se almacena en su firma de metadatos un token que describe el tipo (o clase) del puntero this.
HasThis	32	Especifica una instancia o método virtual (no un método estático). En tiempo de ejecución, se pasa el método llamado como puntero al objeto de destino como primer argumento (el puntero this). La firma almacenada en los metadatos no incluye el tipo de este primer argumento, ya que se conoce el método y puede detectarse su clase propietaria a partir de los metadatos.
Standard	1	Especifica la convención de llamada predeterminada según lo establecido por Common Language Runtime. Utilice esta convención de llamada para los métodos estáticos. Por ejemplo, los métodos virtuales utilizan HasThis.
VarArgs	2	Especifica la convención de llamada para los métodos con argumentos variables.

Ejemplos

C#

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

Comentarios

La convención de llamada nativa es el conjunto de reglas que rigen el orden y el diseño de los argumentos pasados a métodos compilados. También rige cómo pasar el valor devuelto, qué registros se usan para argumentos y si el método llamado o el método que realiza la llamada quita los argumentos de la pila.

Se aplica a