Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

CallingConventions-Enumeration

Aktualisiert: November 2007

Definiert die gültigen Aufrufkonventionen für eine Methode.

Diese Enumeration verfügt über ein ComVisibleAttribute-Attribut, das die bitweise Kombination der Memberwerte zulässt.

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

[SerializableAttribute]
[ComVisibleAttribute(true)]
[FlagsAttribute]
public enum CallingConventions
/** @attribute SerializableAttribute */ 
/** @attribute ComVisibleAttribute(true) */
/** @attribute FlagsAttribute */
public enum CallingConventions
public enum CallingConventions

MembernameBeschreibung
xkkkzc6k.CFW(de-de,VS.90).gifxkkkzc6k.xna(de-de,VS.90).gifStandardGibt die Standardaufrufkonvention an, die durch die Common Language Runtime bestimmt wurde. Verwenden Sie diese Aufrufkonvention für statische Methoden. Verwenden Sie HasThis für Instanzen oder virtuelle Methoden.
xkkkzc6k.CFW(de-de,VS.90).gifxkkkzc6k.xna(de-de,VS.90).gifVarArgsGibt die Aufrufkonvention für Methoden mit variablen Argumenten an.
xkkkzc6k.CFW(de-de,VS.90).gifxkkkzc6k.xna(de-de,VS.90).gifAnyGibt an, dass entweder die Standard-Aufrufkonvention oder die VarArgs-Aufrufkonvention verwendet werden kann.
xkkkzc6k.CFW(de-de,VS.90).gifxkkkzc6k.xna(de-de,VS.90).gifHasThisGibt eine Instanz oder eine virtuelle Methode (keine statische Methode) an. Zur Laufzeit wird der aufgerufenen Methode als erstes Argument ein Zeiger auf das Zielobjekt übergeben (der this-Zeiger). Die in den Metadaten gespeicherte Signatur enthält den Typ dieses ersten Arguments nicht, da die Methode bekannt ist und die Klasse, die diese besitzt, aus den Metadaten ermittelt werden kann.
xkkkzc6k.CFW(de-de,VS.90).gifxkkkzc6k.xna(de-de,VS.90).gifExplicitThisGibt an, dass es sich bei der Signatur um eine Funktionszeiger-Signatur handelt, die einen Aufruf einer Instanz oder einer virtuellen Methode (keiner statischen Methode) darstellt. Wenn ExplicitThis festgelegt ist, muss HasThis ebenfalls festgelegt werden. Das erste an die aufgerufene Methode übergebene Argument ist weiterhin ein this-Zeiger, der Typ des ersten Arguments ist jedoch jetzt unbekannt. Deshalb wird ein Token, das den Typ (oder die Klasse) des this-Zeigers beschreibt, in der Signatur der Metadaten explizit gespeichert.

Die systemeigene Aufrufkonvention ist der Regelsatz, der die Reihenfolge und das Layout der an kompilierte Methoden übergebenen Argumente festlegt. Darüber hinaus wird geregelt, wie der Rückgabewert übergeben wird, welche Register für Argumente verwendet werden und ob die aufgerufene oder die aufrufende Methode Argumente aus dem Stapel entfernen.

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


Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC, Xbox 360

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 3.5, 2.0, 1.0

XNA Framework

Unterstützt in: 2.0, 1.0
Anzeigen: