CallingConventions Enumeration
Defines the valid calling conventions for an enumeration.
This enumeration has a FlagsAttribute attribute that allows a bitwise combination of its member values.
[Visual Basic] <Flags> <Serializable> Public Enum CallingConventions [C#] [Flags] [Serializable] public enum CallingConventions [C++] [Flags] [Serializable] __value public enum CallingConventions [JScript] public Flags Serializable enum CallingConventions
Remarks
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.
Members
| Member name | Description | Value |
|---|---|---|
| Any Supported by the .NET Compact Framework. | Specifies that either the Standard or the VarArgs calling convention may be used. | 3 |
| ExplicitThis Supported by the .NET Compact Framework. | Specifies that the signature is a function-pointer signature, representing a call to an instance or virtual method (not a static method). 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. | 64 |
| HasThis Supported by the .NET Compact Framework. | Specifies an instance or virtual method (not a static method). 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. | 32 |
| Standard Supported by the .NET Compact Framework. | Specifies the default calling convention as determined by the common language runtime. | 1 |
| VarArgs Supported by the .NET Compact Framework. | Specifies the calling convention for methods with variable arguments. | 2 |
Example
[Visual Basic] 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 [C#] 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); } } } [C++] #using <mscorlib.dll> using namespace System; using namespace System::Reflection; using namespace System::Security; public __gc class MyClass1 { public: MyClass1(int i) {} } ; int main() { try { Type* myType = __typeof(MyClass1); Type* types[] = new Type*[1]; types->Item[0] = __typeof(int); // Get the public instance constructor that takes an integer parameter. ConstructorInfo* constructorInfoObj = myType->GetConstructor(static_cast<BindingFlags>(BindingFlags::Instance | BindingFlags::Public), 0, CallingConventions::HasThis, types, 0); if (constructorInfoObj != 0) { Console::WriteLine(S"The constructor of MyClass1 that is a public instance method and takes an integer as a parameter is: "); Console::WriteLine(constructorInfoObj); } else { Console::WriteLine(S"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(S"ArgumentNullException: {0}", e->Message); } catch (ArgumentException* e) { Console::WriteLine(S"ArgumentException: {0}", e->Message); } catch (SecurityException* e) { Console::WriteLine(S"SecurityException: {0}", e->Message); } catch (Exception* e) { Console::WriteLine(S"Exception: {0}", e->Message); } }
[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button
in the upper-left corner of the page.
Requirements
Namespace: System.Reflection
Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework
Assembly: Mscorlib (in Mscorlib.dll)