DynamicMethod Konstruktoren

Referenz

Definition

Namespace:: System.Reflection.Emit

Assembly:: System.Reflection.Emit.Lightweight.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Paket:: System.Reflection.Emit.Lightweight v4.7.0

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Erstellt eine dynamische Methode.

Überlädt

DynamicMethod(String, Type, Type[])	Initialisiert eine anonym gehostete dynamische Methode, wobei der Methodenname, der Rückgabetyp und die Parametertypen angegeben werden.
DynamicMethod(String, Type, Type[], Boolean)	Initialisiert eine anonym gehostete dynamische Methode. Dazu werden der Methodenname, der Rückgabetyp und die Parametertypen angegeben und wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.
DynamicMethod(String, Type, Type[], Module)	Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und den Methodennamen, den Rückgabetyp, die Parametertypen und das Modul angibt.
DynamicMethod(String, Type, Type[], Type)	Erstellt eine dynamische Methode und gibt den Methodennamen, den Rückgabetyp, die Parametertypen und den Typ an, dem die dynamische Methode logisch zugeordnet ist.
DynamicMethod(String, Type, Type[], Module, Boolean)	Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und den Methodennamen, Rückgabetyp, die Parametertypen und das Modul angibt. Zudem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.
DynamicMethod(String, Type, Type[], Type, Boolean)	Erstellt eine dynamische Methode. Dabei werden der Methodenname, der Rückgabetyp, die Parametertypen und der Typ angegeben, der der dynamischen Methode logisch zugeordnet ist. Außerdem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die die MSIL (Microsoft Intermediate Language) der dynamischen Methode zugreift.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und Methodennamen, Attribute, die Aufrufkonvention, den Rückgabetyp, die Parametertypen und das Modul angibt. Zudem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	Erstellt eine dynamische Methode. Dabei werden der Methodenname, die Attribute, die Aufrufkonvention, der Rückgabetyp, die Parametertypen und der Typ angegeben, der der dynamischen Methode logisch zugeordnet ist. Außerdem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die die MSIL (Microsoft Intermediate Language) der dynamischen Methode zugreift.

DynamicMethod(String, Type, Type[])

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Initialisiert eine anonym gehostete dynamische Methode, wobei der Methodenname, der Rückgabetyp und die Parametertypen angegeben werden.

public:
 DynamicMethod(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ parameterTypes);

public DynamicMethod (string name, Type? returnType, Type[]? parameterTypes);

public DynamicMethod (string name, Type returnType, Type[] parameterTypes);

new System.Reflection.Emit.DynamicMethod : string * Type * Type[] -> System.Reflection.Emit.DynamicMethod

Public Sub New (name As String, returnType As Type, parameterTypes As Type())

Parameter

name: String

Der Name der dynamischen Methode. Dies kann eine leere Zeichenfolge sein, sie darf aber nicht null sein.

returnType: Type

Ein Type-Objekt, das den Rückgabetyp der dynamischen Methode angibt, oder null, wenn die Methode keinen Rückgabetyp hat.

parameterTypes: Type[]

Ein Array von Type-Objekten, die die Typen der Parameter der dynamischen Methode angeben, oder null, wenn die Methode keine Parameter hat.

Ausnahmen

ArgumentException

Ein Element von parameterTypes ist null oder Void.

ArgumentNullException

name ist null.

NotSupportedException

.NET Framework und .NET Core-Versionen, die älter als 2.1 sind: returnType ist ein Typ, für den IsByRef zurückgegeben wirdtrue.

Hinweise

Die dynamische Methode, die von diesem Konstruktor erstellt wird, ist einer anonymen Assembly anstelle eines vorhandenen Typs oder Moduls zugeordnet. Die anonyme Assembly ist nur vorhanden, um eine Sandboxumgebung für dynamische Methoden bereitzustellen, d. h. sie von anderen Code zu isolieren. Diese Umgebung macht es sicher, dass die dynamische Methode von teilweise vertrauenswürdigem Code ausgegeben und ausgeführt wird.

Dieser Konstruktor gibt an, dass JIT-Sichtbarkeitsprüfungen (Just-in-Time) für die Microsoft Intermediate Language (MSIL) der dynamischen Methode erzwungen werden. Das heißt, der Code in der dynamischen Methode hat Zugriff auf öffentliche Methoden öffentlicher Klassen. Ausnahmen werden ausgelöst, wenn die Methode versucht, auf Typen oder Member zuzugreifen, die , protectedoder internal (Friend in Visual Basic) sindprivate. Verwenden Sie den -Konstruktor, um eine dynamische Methode zu erstellen, die eingeschränkte Möglichkeiten zum Überspringen von DynamicMethod(String, Type, Type[], Boolean) JIT-Sichtbarkeitsprüfungen aufweist.

Wenn eine anonym gehostete dynamische Methode erstellt wird, wird die Aufrufliste der ausgebenden Assembly eingeschlossen. Wenn die -Methode aufgerufen wird, werden die Berechtigungen der ausgebenden Assembly anstelle der Berechtigungen des tatsächlichen Aufrufers verwendet. Daher kann die dynamische Methode nicht auf einer höheren Berechtigungsebene als die der Assembly ausgeführt werden, die sie ausgegeben hat, auch wenn sie an eine Assembly übergeben und von dieser ausgeführt wird, die über eine höhere Vertrauensebene verfügt.

Dieser Konstruktor gibt die Methodenattribute MethodAttributes.Public und und MethodAttributes.Staticdie aufrufende Konvention CallingConventions.Standardan.

Hinweis

Dieser Konstruktor wurde im .NET Framework 3.5 oder höher eingeführt.

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Boolean)

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Initialisiert eine anonym gehostete dynamische Methode. Dazu werden der Methodenname, der Rückgabetyp und die Parametertypen angegeben und wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.

public:
 DynamicMethod(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ parameterTypes, bool restrictedSkipVisibility);

public DynamicMethod (string name, Type? returnType, Type[]? parameterTypes, bool restrictedSkipVisibility);

public DynamicMethod (string name, Type returnType, Type[] parameterTypes, bool restrictedSkipVisibility);

new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * bool -> System.Reflection.Emit.DynamicMethod

Public Sub New (name As String, returnType As Type, parameterTypes As Type(), restrictedSkipVisibility As Boolean)

Parameter

name: String

Der Name der dynamischen Methode. Dies kann eine leere Zeichenfolge sein, sie darf aber nicht null sein.

returnType: Type

Ein Type-Objekt, das den Rückgabetyp der dynamischen Methode angibt, oder null, wenn die Methode keinen Rückgabetyp hat.

parameterTypes: Type[]

Ein Array von Type-Objekten, die die Typen der Parameter der dynamischen Methode angeben, oder null, wenn die Methode keine Parameter hat.

restrictedSkipVisibility: Boolean

true, wenn JIT-Sichtbarkeitsprüfungen für Typen und Member übersprungen werden sollen, auf die durch die MSIL der dynamischen Methode zugegriffen wird. Dafür gibt es folgende Einschränkung: Die Vertrauensebene der Assemblys, die diese Typen und Member enthalten, muss identisch sein mit oder kleiner sein als die Vertrauensebene der Aufrufliste, die die dynamische Methode ausgibt. Andernfalls false.

Ausnahmen

ArgumentException

Ein Element von parameterTypes ist null oder Void.

ArgumentNullException

name ist null.

NotSupportedException

.NET Framework und .NET Core-Versionen, die älter als 2.1 sind: returnType ist ein Typ, für den IsByRef zurückgegeben wirdtrue.

Hinweise

Anonym gehostete dynamische Methoden haben keinen automatischen Zugriff auf Typen oder Member, die , protectedoder internal (Friend in Visual Basic) sindprivate. Dies unterscheidet sich von dynamischen Methoden, die einem vorhandenen Typ oder Modul zugeordnet sind und Zugriff auf ausgeblendete Member im zugeordneten Bereich haben.

Geben Sie für restrictedSkipVisibility antrue, ob Ihre dynamische Methode auf Typen oder Member zugreifen muss, die , protectedoder internalsindprivate. Dadurch erhält die dynamische Methode eingeschränkten Zugriff auf diese Member. Das heißt, auf die Member kann nur zugegriffen werden, wenn die folgenden Bedingungen erfüllt sind:

Die Zielmember gehören zu einer Assembly, deren Vertrauensebene gleich oder niedriger ist als die Aufrufliste, die die dynamische Methode ausgibt.
Die Aufrufliste, die die dynamische Methode ausgibt, wird mit dem ReflectionPermissionFlag.RestrictedMemberAccess Flag gewährtReflectionPermission. Dies gilt immer, wenn der Code mit voller Vertrauenswürdigheit ausgeführt wird. Für teilweise vertrauenswürdigen Code gilt dies nur, wenn der Host die Berechtigung explizit erteilt.

Wichtig

Wenn die Berechtigung nicht erteilt wurde, wird eine Sicherheits exception ausgelöst, wenn CreateDelegate aufgerufen wird oder wenn die dynamische Methode aufgerufen wird, nicht beim Aufruf dieses Konstruktors. Zum Ausgeben der dynamischen Methode sind keine speziellen Berechtigungen erforderlich.

Beispielsweise kann eine dynamische Methode, die mit restrictedSkipVisibility festgelegt auf true erstellt wird, auf ein privates Element einer beliebigen Assembly in der Aufrufliste zugreifen, wenn der Aufrufliste eingeschränkter Memberzugriff gewährt wurde. Wenn die dynamische Methode mit teilweise vertrauenswürdigem Code in der Aufrufliste erstellt wird, kann sie nicht auf ein privates Element eines Typs in einer .NET Framework Assembly zugreifen, da solche Assemblys vollständig vertrauenswürdig sind.

Wenn restrictedSkipVisibility ist false, werden JIT-Sichtbarkeitsprüfungen erzwungen. Der Code in der dynamischen Methode hat Zugriff auf öffentliche Methoden öffentlicher Klassen, und Ausnahmen werden ausgelöst, wenn versucht wird, auf Typen oder Member zuzugreifen, die , protectedoder internalsindprivate.

Wenn eine anonym gehostete dynamische Methode erstellt wird, wird die Aufrufliste der ausgebenden Assembly eingeschlossen. Wenn die -Methode aufgerufen wird, werden die Berechtigungen der ausgebenden Aufrufliste anstelle der Berechtigungen des tatsächlichen Aufrufers verwendet. Daher kann die dynamische Methode nicht auf einer höheren Berechtigungsebene als die der Assembly ausgeführt werden, die sie ausgegeben hat, auch wenn sie an eine Assembly übergeben und von dieser ausgeführt wird, die über eine höhere Vertrauensebene verfügt.

Dieser Konstruktor gibt die Methodenattribute MethodAttributes.Public und und MethodAttributes.Staticdie aufrufende Konvention CallingConventions.Standardan.

Hinweis

Dieser Konstruktor wurde im .NET Framework 3.5 oder höher eingeführt.

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Module)

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und den Methodennamen, den Rückgabetyp, die Parametertypen und das Modul angibt.

public:
 DynamicMethod(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ parameterTypes, System::Reflection::Module ^ m);

public DynamicMethod (string name, Type? returnType, Type[]? parameterTypes, System.Reflection.Module m);

public DynamicMethod (string name, Type returnType, Type[] parameterTypes, System.Reflection.Module m);

new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * System.Reflection.Module -> System.Reflection.Emit.DynamicMethod

Public Sub New (name As String, returnType As Type, parameterTypes As Type(), m As Module)

Parameter

name: String

Der Name der dynamischen Methode. Dies kann eine leere Zeichenfolge sein, sie darf aber nicht null sein.

returnType: Type

Ein Type-Objekt, das den Rückgabetyp der dynamischen Methode angibt, oder null, wenn die Methode keinen Rückgabetyp hat.

parameterTypes: Type[]

Ein Array von Type-Objekten, die die Typen der Parameter der dynamischen Methode angeben, oder null, wenn die Methode keine Parameter hat.

m: Module

Ein Module, das das Modul darstellt, dem die dynamische Methode logisch zugeordnet ist.

Ausnahmen

ArgumentException

Ein Element von parameterTypes ist null oder Void.

- oder -

m ist ein Modul, das das anonyme Hosten für dynamische Methoden bereitstellt.

ArgumentNullException

name ist null.

- oder -

m ist null.

NotSupportedException

.NET Framework und .NET Core-Versionen, die älter als 2.1 sind: returnType ist ein Typ, für den IsByRef zurückgegeben wirdtrue.

Beispiele

Im folgenden Codebeispiel wird eine dynamische Methode erstellt, die zwei Parameter akzeptiert. Im Beispiel wird ein einfacher Funktionstext ausgegeben, der den ersten Parameter an die Konsole ausgibt, und im Beispiel wird der zweite Parameter als Rückgabewert der -Methode verwendet. Im Beispiel wird die -Methode durch Erstellen eines Delegaten abgeschlossen, der Delegat mit verschiedenen Parametern aufgerufen und schließlich die dynamische Methode mithilfe der Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) -Methode aufgerufen.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

public ref class Test
{   
};

// Declare a delegate that will be used to execute the completed
// dynamic method.
delegate int HelloInvoker(String^ msg, int ret);

int main()
{
    // Create an array that specifies the types of the parameters
    // of the dynamic method. This method has a string parameter
    // and an int parameter.
    array<Type^>^ helloArgs = {String::typeid, int::typeid};

    // Create a dynamic method with the name "Hello", a return type
    // of int, and two parameters whose types are specified by the
    // array helloArgs. Create the method in the module that
    // defines the Test class.
    DynamicMethod^ hello = gcnew DynamicMethod("Hello", 
        int::typeid,
        helloArgs,
        Test::typeid->Module);

    // Create an array that specifies the parameter types of the
    // overload of Console.WriteLine to be used in Hello.
    array<Type^>^ writeStringArgs = {String::typeid};
    // Get the overload of Console.WriteLine that has one
    // String parameter.
    MethodInfo^ writeString =
        Console::typeid->GetMethod("WriteLine", writeStringArgs);

    // Get an ILGenerator and emit a body for the dynamic method.
    ILGenerator^ ilgen = hello->GetILGenerator();
    // Load the first argument, which is a string, onto the stack.
    ilgen->Emit(OpCodes::Ldarg_0);
    // Call the overload of Console.WriteLine that prints a string.
    ilgen->EmitCall(OpCodes::Call, writeString, nullptr);
    // The Hello method returns the value of the second argument;
    // to do this, load the onto the stack and return.
    ilgen->Emit(OpCodes::Ldarg_1);
    ilgen->Emit(OpCodes::Ret);

    // Create a delegate that represents the dynamic method. This
    // action completes the method, and any further attempts to
    // change the method will cause an exception.
    HelloInvoker^ helloDelegate =
        (HelloInvoker^) hello->CreateDelegate(HelloInvoker::typeid);

    // Use the delegate to execute the dynamic method. Save and
    // print the return value.
    int returnValue = helloDelegate("\r\nHello, World!", 42);
    Console::WriteLine("helloDelegate(\"Hello, World!\", 42) returned {0}",
        returnValue);

    // Do it again, with different arguments.
    returnValue = helloDelegate("\r\nHi, Mom!", 5280);
    Console::WriteLine("helloDelegate(\"Hi, Mom!\", 5280) returned {0}",
        returnValue);

    // Create an array of arguments to use with the Invoke method.
    array<Object^>^ delegateArgs = {"\r\nHello, World!", 42};
    // Invoke the dynamic method using the arguments. This is much
    // slower than using the delegate, because you must create an
    // array to contain the arguments, and ValueType arguments
    // must be boxed.
    Object^ returnValueObject = hello->Invoke(nullptr, delegateArgs);
    Console::WriteLine("hello.Invoke returned {0}", returnValueObject);
}

using System;
using System.Reflection;
using System.Reflection.Emit;
using Microsoft.VisualBasic;

public class Test
{
    // Declare a delegate that will be used to execute the completed
    // dynamic method.
    private delegate int HelloInvoker(string msg, int ret);

    public static void Main()
    {
        // Create an array that specifies the types of the parameters
        // of the dynamic method. This method has a string parameter
        // and an int parameter.
        Type[] helloArgs = {typeof(string), typeof(int)};

        // Create a dynamic method with the name "Hello", a return type
        // of int, and two parameters whose types are specified by the
        // array helloArgs. Create the method in the module that
        // defines the Test class.
        DynamicMethod hello = new DynamicMethod("Hello",
            typeof(int),
            helloArgs,
            typeof(Test).Module);

        // Create an array that specifies the parameter types of the
        // overload of Console.WriteLine to be used in Hello.
        Type[] writeStringArgs = {typeof(string)};
        // Get the overload of Console.WriteLine that has one
        // String parameter.
        MethodInfo writeString =
            typeof(Console).GetMethod("WriteLine", writeStringArgs);

        // Get an ILGenerator and emit a body for the dynamic method.
        ILGenerator il = hello.GetILGenerator();
        // Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0);
        // Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, null);
        // The Hello method returns the value of the second argument;
        // to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ret);

        // Create a delegate that represents the dynamic method. This
        // action completes the method, and any further attempts to
        // change the method will cause an exception.
        HelloInvoker hi =
            (HelloInvoker) hello.CreateDelegate(typeof(HelloInvoker));

        // Use the delegate to execute the dynamic method. Save and
        // print the return value.
        int retval = hi("\r\nHello, World!", 42);
        Console.WriteLine("Executing delegate hi(\"Hello, World!\", 42) returned {0}",
            retval);

        // Do it again, with different arguments.
        retval = hi("\r\nHi, Mom!", 5280);
        Console.WriteLine("Executing delegate hi(\"Hi, Mom!\", 5280) returned {0}",
            retval);

        // Create an array of arguments to use with the Invoke method.
        object[] invokeArgs = {"\r\nHello, World!", 42};
        // Invoke the dynamic method using the arguments. This is much
        // slower than using the delegate, because you must create an
        // array to contain the arguments, and ValueType arguments
        // must be boxed.
        object objRet = hello.Invoke(null, invokeArgs);
        Console.WriteLine("hello.Invoke returned {0}", objRet);
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Public Class Test
    ' Declare a delegate that will be used to execute the completed
    ' dynamic method. 
    Private Delegate Function HelloInvoker(ByVal msg As String, _
        ByVal ret As Integer) As Integer

    Public Shared Sub Main()
        ' Create an array that specifies the types of the parameters
        ' of the dynamic method. This method has a String parameter
        ' and an Integer parameter.
        Dim helloArgs() As Type = {GetType(String), GetType(Integer)}

        ' Create a dynamic method with the name "Hello", a return type
        ' of Integer, and two parameters whose types are specified by
        ' the array helloArgs. Create the method in the module that
        ' defines the Test class.
        Dim hello As New DynamicMethod("Hello", _
            GetType(Integer), _
            helloArgs, _
            GetType(Test).Module)

        ' Create an array that specifies the parameter types of the
        ' overload of Console.WriteLine to be used in Hello.
        Dim writeStringArgs() As Type = {GetType(String)}
        ' Get the overload of Console.WriteLine that has one
        ' String parameter.
        Dim writeString As MethodInfo = GetType(Console). _
            GetMethod("WriteLine", writeStringArgs) 

        ' Get an ILGenerator and emit a body for the dynamic method.
        Dim il As ILGenerator = hello.GetILGenerator()
        ' Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0)
        ' Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, Nothing)
        ' The Hello method returns the value of the second argument;
        ' to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1)
        il.Emit(OpCodes.Ret)

        ' Create a delegate that represents the dynamic method. This
        ' action completes the method, and any further attempts to
        ' change the method will cause an exception.
    Dim hi As HelloInvoker = _
            hello.CreateDelegate(GetType(HelloInvoker))

        ' Use the delegate to execute the dynamic method. Save and
        ' print the return value.
        Dim retval As Integer = hi(vbCrLf & "Hello, World!", 42)
        Console.WriteLine("Executing delegate hi(""Hello, World!"", 42) returned " _
            & retval)

        ' Do it again, with different arguments.
        retval = hi(vbCrLf & "Hi, Mom!", 5280)
        Console.WriteLine("Executing delegate hi(""Hi, Mom!"", 5280) returned " _
            & retval)

        ' Create an array of arguments to use with the Invoke method.
        Dim invokeArgs() As Object = {vbCrLf & "Hello, World!", 42}
        ' Invoke the dynamic method using the arguments. This is much
        ' slower than using the delegate, because you must create an
        ' array to contain the arguments, and ValueType arguments
        ' must be boxed. Note that this overload of Invoke is 
        ' inherited from MethodBase, and simply calls the more 
        ' complete overload of Invoke.
        Dim objRet As Object = hello.Invoke(Nothing, invokeArgs)
        Console.WriteLine("hello.Invoke returned " & objRet)
    End Sub
End Class

' This code example produces the following output:
'
'Hello, World!
'Executing delegate hi("Hello, World!", 42) returned 42
'
'Hi, Mom!
'Executing delegate hi("Hi, Mom!", 5280) returned 5280
'
'Hello, World!
'hello.Invoke returned 42
'

Hinweise

Dieser Konstruktor gibt Methodenattribute MethodAttributes.Public und MethodAttributes.Statican, ruft konvention CallingConventions.Standardauf und überspringt keine JIT-Sichtbarkeitsprüfungen (Just-in-Time).

Die mit diesem Konstruktor erstellte dynamische Methode hat Zugriff auf öffentliche und internal (Friend in Visual Basic) Member aller Typen, die im Modul menthalten sind.

Hinweis

Aus Gründen der Abwärtskompatibilität erfordert SecurityPermission dieser Konstruktor das SecurityPermissionFlag.ControlEvidence Flag, wenn die folgenden Bedingungen erfüllt sind: m ist ein anderes Modul als das aufrufende Modul, und die Anforderung für ReflectionPermission mit dem ReflectionPermissionFlag.MemberAccess Flag ist fehlgeschlagen. Wenn die Anforderung erfolgreich SecurityPermission ist, ist der Vorgang zulässig.

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Type)

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Erstellt eine dynamische Methode und gibt den Methodennamen, den Rückgabetyp, die Parametertypen und den Typ an, dem die dynamische Methode logisch zugeordnet ist.

public:
 DynamicMethod(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ parameterTypes, Type ^ owner);

public DynamicMethod (string name, Type? returnType, Type[]? parameterTypes, Type owner);

public DynamicMethod (string name, Type returnType, Type[] parameterTypes, Type owner);

new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * Type -> System.Reflection.Emit.DynamicMethod

Public Sub New (name As String, returnType As Type, parameterTypes As Type(), owner As Type)

Parameter

name: String

Der Name der dynamischen Methode. Dies kann eine leere Zeichenfolge sein, sie darf aber nicht null sein.

returnType: Type

Ein Type-Objekt, das den Rückgabetyp der dynamischen Methode angibt, oder null, wenn die Methode keinen Rückgabetyp hat.

parameterTypes: Type[]

Ein Array von Type-Objekten, die die Typen der Parameter der dynamischen Methode angeben, oder null, wenn die Methode keine Parameter hat.

owner: Type

Ein Type, der der dynamischen Methode logisch zugeordnet ist. Die dynamische Methode hat Zugriff auf alle Member des Typs.

Ausnahmen

ArgumentException

Ein Element von parameterTypes ist null oder Void.

- oder -

owner ist eine Schnittstelle, ein Array, ein offener generischer Typ oder ein Typparameter eines generischen Typs oder einer Methode.

ArgumentNullException

name ist null.

- oder -

owner ist null.

NotSupportedException

.NET Framework und .NET Core-Versionen, die älter als 2.1 sind: returnType ist ein Typ, für den IsByRef zurückgegeben wirdtrue.

Beispiele

Im folgenden Codebeispiel wird ein DynamicMethod erstellt, das einem Typ logisch zugeordnet ist. Diese Zuordnung gewährt ihr Zugriff auf die privaten Mitglieder dieses Typs.

Das Codebeispiel definiert eine Klasse namens Example mit einem privaten Feld, eine Klasse namens DerivedFromExample , die von der ersten Klasse abgeleitet wird, einen Delegattyp namens, UseLikeStatic der zurückgibt Int32 und Parameter vom Typ Example und Int32aufweist, und einen Delegattyp namens, UseLikeInstance der zurückgibt Int32 und einen Parameter vom Typ Int32aufweist.

Der Beispielcode erstellt dann ein DynamicMethod , das das private Feld einer instance von Example ändert und den vorherigen Wert zurückgibt.

Hinweis

Im Allgemeinen ist das Ändern der internen Klassenfelder keine gute objektorientierte Codierungspraxis.

Der Beispielcode erstellt eine instance von Example und dann zwei Delegaten. Die erste ist vom Typ UseLikeStatic, der über die gleichen Parameter wie die dynamische Methode verfügt. Der zweite ist vom Typ UseLikeInstance, dem der erste Parameter (vom Typ Example) fehlt. Dieser Delegat wird mithilfe der CreateDelegate(Type, Object) Methodenüberladung erstellt. Der zweite Parameter dieser Methodenüberladung ist ein instance von Example, in diesem Fall die gerade erstellte instance, die an den neu erstellten Delegaten gebunden ist. Wenn dieser Delegat aufgerufen wird, wirkt die dynamische Methode auf den gebundenen instance von Example.

Hinweis

Dies ist ein Beispiel für die gelockerten Regeln für die Delegatbindung, die im .NET Framework 2.0 eingeführt wurden, zusammen mit neuen Überladungen der Delegate.CreateDelegate -Methode. Weitere Informationen finden Sie in den Ausführungen zur Delegate-Klasse.

Der UseLikeStatic Delegat wird aufgerufen, wobei die instance übergeben wird, die Example an den UseLikeInstance Delegaten gebunden ist. Anschließend wird der UseLikeInstance Delegat aufgerufen, sodass beide Delegaten auf demselben instance von Exampleagieren. Die Änderungen an den Werten des internen Felds werden nach jedem Aufruf angezeigt. Schließlich ist ein UseLikeInstance Delegat an eine instance von DerivedFromExamplegebunden, und die Delegataufrufe werden wiederholt.

using System;
using System.Reflection;
using System.Reflection.Emit;

// These classes are for demonstration purposes.
//
public class Example
{
    private int id = 0;
    public Example(int id)
    {
        this.id = id;
    }
    public int ID { get { return id; }}
}

public class DerivedFromExample : Example
{
    public DerivedFromExample(int id) : base(id) {}
}

// Two delegates are declared: UseLikeInstance treats the dynamic
// method as if it were an instance method, and UseLikeStatic
// treats the dynamic method in the ordinary fashion.
//
public delegate int UseLikeInstance(int newID);
public delegate int UseLikeStatic(Example ex, int newID);

public class Demo
{
    public static void Main()
    {
        // This dynamic method changes the private id field. It has
        // no name; it returns the old id value (return type int);
        // it takes two parameters, an instance of Example and
        // an int that is the new value of id; and it is declared
        // with Example as the owner type, so it can access all
        // members, public and private.
        //
        DynamicMethod changeID = new DynamicMethod(
            "",
            typeof(int),
            new Type[] { typeof(Example), typeof(int) },
            typeof(Example)
        );

        // Get a FieldInfo for the private field 'id'.
        FieldInfo fid = typeof(Example).GetField(
            "id",
            BindingFlags.NonPublic | BindingFlags.Instance
        );

        ILGenerator ilg = changeID.GetILGenerator();

        // Push the current value of the id field onto the
        // evaluation stack. It's an instance field, so load the
        // instance of Example before accessing the field.
        ilg.Emit(OpCodes.Ldarg_0);
        ilg.Emit(OpCodes.Ldfld, fid);

        // Load the instance of Example again, load the new value
        // of id, and store the new field value.
        ilg.Emit(OpCodes.Ldarg_0);
        ilg.Emit(OpCodes.Ldarg_1);
        ilg.Emit(OpCodes.Stfld, fid);

        // The original value of the id field is now the only
        // thing on the stack, so return from the call.
        ilg.Emit(OpCodes.Ret);

        // Create a delegate that uses changeID in the ordinary
        // way, as a static method that takes an instance of
        // Example and an int.
        //
        UseLikeStatic uls =
            (UseLikeStatic) changeID.CreateDelegate(
                typeof(UseLikeStatic)
            );

        // Create an instance of Example with an id of 42.
        //
        Example ex = new Example(42);

        // Create a delegate that is bound to the instance of
        // of Example. This is possible because the first
        // parameter of changeID is of type Example. The
        // delegate has all the parameters of changeID except
        // the first.
        UseLikeInstance uli =
            (UseLikeInstance) changeID.CreateDelegate(
                typeof(UseLikeInstance),
                ex
            );

        // First, change the value of id by calling changeID as
        // a static method, passing in the instance of Example.
        //
        Console.WriteLine(
            "Change the value of id; previous value: {0}",
            uls(ex, 1492)
        );

        // Change the value of id again using the delegate bound
        // to the instance of Example.
        //
        Console.WriteLine(
            "Change the value of id; previous value: {0}",
            uli(2700)
        );

        Console.WriteLine("Final value of id: {0}", ex.ID);

        // Now repeat the process with a class that derives
        // from Example.
        //
        DerivedFromExample dfex = new DerivedFromExample(71);

        uli = (UseLikeInstance) changeID.CreateDelegate(
                typeof(UseLikeInstance),
                dfex
            );

        Console.WriteLine(
            "Change the value of id; previous value: {0}",
            uls(dfex, 73)
        );
        Console.WriteLine(
            "Change the value of id; previous value: {0}",
            uli(79)
        );
        Console.WriteLine("Final value of id: {0}", dfex.ID);
    }
}

/* This code example produces the following output:

Change the value of id; previous value: 42
Change the value of id; previous value: 1492
Final value of id: 2700
Change the value of id; previous value: 71
Change the value of id; previous value: 73
Final value of id: 79
 */

Imports System.Reflection
Imports System.Reflection.Emit

' These classes are for demonstration purposes.
'
Public Class Example
    Private _id As Integer = 0
    
    Public Sub New(ByVal newId As Integer) 
        _id = newId    
    End Sub
    
    Public ReadOnly Property ID() As Integer 
        Get
            Return _id
        End Get
    End Property 
End Class

Public Class DerivedFromExample
    Inherits Example
    
    Public Sub New(ByVal newId As Integer) 
        MyBase.New(newId)
    End Sub
End Class
 
' Two delegates are declared: UseLikeInstance treats the dynamic
' method as if it were an instance method, and UseLikeStatic
' treats the dynamic method in the ordinary fashion.
' 
Public Delegate Function UseLikeInstance(ByVal newID As Integer) _
    As Integer 
Public Delegate Function UseLikeStatic(ByVal ex As Example, _
    ByVal newID As Integer) As Integer 

Public Class Demo
    
    Public Shared Sub Main() 
        ' This dynamic method changes the private _id field. It 
        ' has no name; it returns the old _id value (return type 
        ' Integer); it takes two parameters, an instance of Example 
        ' and an Integer that is the new value of _id; and it is 
        ' declared with Example as the owner type, so it can 
        ' access all members, public and private.
        '
        Dim changeID As New DynamicMethod( _
            "", _
            GetType(Integer), _
            New Type() {GetType(Example), GetType(Integer)}, _
            GetType(Example) _
        )
        
        ' Get a FieldInfo for the private field '_id'.
        Dim fid As FieldInfo = GetType(Example).GetField( _
            "_id", _
            BindingFlags.NonPublic Or BindingFlags.Instance _
        )
        
        Dim ilg As ILGenerator = changeID.GetILGenerator()
        
        ' Push the current value of the id field onto the 
        ' evaluation stack. It's an instance field, so load the
        ' instance of Example before accessing the field.
        ilg.Emit(OpCodes.Ldarg_0)
        ilg.Emit(OpCodes.Ldfld, fid)
        
        ' Load the instance of Example again, load the new value 
        ' of id, and store the new field value. 
        ilg.Emit(OpCodes.Ldarg_0)
        ilg.Emit(OpCodes.Ldarg_1)
        ilg.Emit(OpCodes.Stfld, fid)
        
        ' The original value of the id field is now the only 
        ' thing on the stack, so return from the call.
        ilg.Emit(OpCodes.Ret)
        
        
        ' Create a delegate that uses changeID in the ordinary
        ' way, as a static method that takes an instance of
        ' Example and an Integer.
        '
        Dim uls As UseLikeStatic = CType( _
            changeID.CreateDelegate(GetType(UseLikeStatic)), _
            UseLikeStatic _
        )
        
        ' Create an instance of Example with an id of 42.
        '
        Dim ex As New Example(42)
        
        ' Create a delegate that is bound to the instance of 
        ' of Example. This is possible because the first 
        ' parameter of changeID is of type Example. The 
        ' delegate has all the parameters of changeID except
        ' the first.
        Dim uli As UseLikeInstance = CType( _
            changeID.CreateDelegate( _
                GetType(UseLikeInstance), _
                ex), _
            UseLikeInstance _
        )
        
        ' First, change the value of _id by calling changeID as
        ' a static method, passing in the instance of Example.
        '
        Console.WriteLine( _
            "Change the value of _id; previous value: {0}", _
            uls(ex, 1492) _
        )
        
        ' Change the value of _id again using the delegate 
        ' bound to the instance of Example.
        '
        Console.WriteLine( _
            "Change the value of _id; previous value: {0}", _
            uli(2700) _
        )
        
        Console.WriteLine("Final value of _id: {0}", ex.ID)
    

        ' Now repeat the process with a class that derives
        ' from Example.
        '
        Dim dfex As New DerivedFromExample(71)

        uli = CType( _
            changeID.CreateDelegate( _
                GetType(UseLikeInstance), _
                dfex), _
            UseLikeInstance _
        )

        Console.WriteLine( _
            "Change the value of _id; previous value: {0}", _
            uls(dfex, 73) _
        )
        Console.WriteLine( _
            "Change the value of _id; previous value: {0}", _
            uli(79) _
        )
        Console.WriteLine("Final value of _id: {0}", dfex.ID)

    End Sub
End Class

' This code example produces the following output:
'
'Change the value of _id; previous value: 42
'Change the value of _id; previous value: 1492
'Final value of _id: 2700
'Change the value of _id; previous value: 71
'Change the value of _id; previous value: 73
'Final value of _id: 79'

Hinweise

Hinweis

Aus Gründen der Abwärtskompatibilität erfordert SecurityPermission dieser Konstruktor das SecurityPermissionFlag.ControlEvidence Flag, wenn die folgenden Bedingungen erfüllt sind: owner befindet sich in einem anderen Modul als dem aufrufenden Modul, und die Anforderung für ReflectionPermission mit dem ReflectionPermissionFlag.MemberAccess Flag ist fehlgeschlagen. Wenn die Anforderung erfolgreich SecurityPermission ist, ist der Vorgang zulässig.

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Module, Boolean)

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und den Methodennamen, Rückgabetyp, die Parametertypen und das Modul angibt. Zudem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.

public:
 DynamicMethod(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ parameterTypes, System::Reflection::Module ^ m, bool skipVisibility);

public DynamicMethod (string name, Type? returnType, Type[]? parameterTypes, System.Reflection.Module m, bool skipVisibility);

public DynamicMethod (string name, Type returnType, Type[] parameterTypes, System.Reflection.Module m, bool skipVisibility);

new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * System.Reflection.Module * bool -> System.Reflection.Emit.DynamicMethod

Public Sub New (name As String, returnType As Type, parameterTypes As Type(), m As Module, skipVisibility As Boolean)

Parameter

name: String

Der Name der dynamischen Methode. Dies kann eine leere Zeichenfolge sein, sie darf aber nicht null sein.

returnType: Type

Ein Type-Objekt, das den Rückgabetyp der dynamischen Methode angibt, oder null, wenn die Methode keinen Rückgabetyp hat.

parameterTypes: Type[]

Ein Array von Type-Objekten, die die Typen der Parameter der dynamischen Methode angeben, oder null, wenn die Methode keine Parameter hat.

m: Module

Ein Module, das das Modul darstellt, dem die dynamische Methode logisch zugeordnet ist.

skipVisibility: Boolean

true, wenn JIT-Sichtbarkeitsprüfungen für Typen und Member übersprungen werden sollen, auf die die MSIL der dynamischen Methode zugreift.

Ausnahmen

ArgumentException

Ein Element von parameterTypes ist null oder Void.

- oder -

m ist ein Modul, das das anonyme Hosten für dynamische Methoden bereitstellt.

ArgumentNullException

name ist null.

- oder -

m ist null.

NotSupportedException

.NET Framework und .NET Core-Versionen, die älter als 2.1 sind: returnType ist ein Typ, für den IsByRef zurückgegeben wirdtrue.

Hinweise

Dieser Konstruktor gibt Methodenattribute MethodAttributes.Public und MethodAttributes.Statican, und ruft die Konvention CallingConventions.Standardauf.

Die mit diesem Konstruktor erstellte dynamische Methode hat Zugriff auf öffentliche und internal (Friend in Visual Basic) Member aller Typen im enthaltenen Modul m. Wenn Sie die Sichtbarkeitsprüfungen des JIT-Compilers überspringen, kann die dynamische Methode auch auf private und geschützte Member aller anderen Typen zugreifen. Dies ist z. B. beim Schreiben von Code zum Serialisieren von Objekten nützlich.

Hinweis

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Type, Boolean)

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Erstellt eine dynamische Methode. Dabei werden der Methodenname, der Rückgabetyp, die Parametertypen und der Typ angegeben, der der dynamischen Methode logisch zugeordnet ist. Außerdem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die die MSIL (Microsoft Intermediate Language) der dynamischen Methode zugreift.

public:
 DynamicMethod(System::String ^ name, Type ^ returnType, cli::array <Type ^> ^ parameterTypes, Type ^ owner, bool skipVisibility);

public DynamicMethod (string name, Type? returnType, Type[]? parameterTypes, Type owner, bool skipVisibility);

public DynamicMethod (string name, Type returnType, Type[] parameterTypes, Type owner, bool skipVisibility);

new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * Type * bool -> System.Reflection.Emit.DynamicMethod

Public Sub New (name As String, returnType As Type, parameterTypes As Type(), owner As Type, skipVisibility As Boolean)

Parameter

name: String

Der Name der dynamischen Methode. Dies kann eine leere Zeichenfolge sein, sie darf aber nicht null sein.

returnType: Type

Ein Type-Objekt, das den Rückgabetyp der dynamischen Methode angibt, oder null, wenn die Methode keinen Rückgabetyp hat.

parameterTypes: Type[]

Ein Array von Type-Objekten, die die Typen der Parameter der dynamischen Methode angeben, oder null, wenn die Methode keine Parameter hat.

owner: Type

Ein Type, der der dynamischen Methode logisch zugeordnet ist. Die dynamische Methode hat Zugriff auf alle Member des Typs.

skipVisibility: Boolean

true, wenn JIT-Sichtbarkeitsprüfungen für Typen und Member übersprungen werden sollen, auf die die MSIL der dynamischen Methode zugreift, andernfalls false.

Ausnahmen

ArgumentException

Ein Element von parameterTypes ist null oder Void.

- oder -

owner ist eine Schnittstelle, ein Array, ein offener generischer Typ oder ein Typparameter eines generischen Typs oder einer Methode.

ArgumentNullException

name ist null.

- oder -

owner ist null.

NotSupportedException

.NET Framework und .NET Core-Versionen, die älter als 2.1 sind: returnType ist ein Typ, für den IsByRef zurückgegeben wirdtrue.

Hinweise

Die mit diesem Konstruktor erstellte dynamische Methode hat Zugriff auf alle Member des Typs ownerund auf öffentliche und internal (Friend in Visual Basic) Member aller anderen Typen im Modul, das enthält owner. Wenn Sie die Sichtbarkeitsprüfungen des JIT-Compilers überspringen, kann die dynamische Methode auch auf private und geschützte Member aller anderen Typen zugreifen. Dies ist z. B. beim Schreiben von Code zum Serialisieren von Objekten nützlich.

Dieser Konstruktor gibt Methodenattribute MethodAttributes.Public und MethodAttributes.Statican, und ruft die Konvention CallingConventions.Standardauf.

Hinweis

Aus Gründen der Abwärtskompatibilität erfordert SecurityPermission dieser Konstruktor das SecurityPermissionFlag.ControlEvidence Flag, wenn die folgenden Bedingungen erfüllt sind: owner befindet sich in einem anderen Modul als dem aufrufenden Modul, und die Anforderung für ReflectionPermission mit dem ReflectionPermissionFlag.MemberAccess Flag ist fehlgeschlagen. Wenn die Anforderung erfolgreich SecurityPermission ist, ist der Vorgang zulässig.

Weitere Informationen

Gilt für:

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Erstellt eine dynamische Methode, die sich zu einem Modul global verhält und Methodennamen, Attribute, die Aufrufkonvention, den Rückgabetyp, die Parametertypen und das Modul angibt. Zudem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die von der MSIL (Microsoft Intermediate Language) der dynamischen Methode zugegriffen wird.

public:
 DynamicMethod(System::String ^ name, System::Reflection::MethodAttributes attributes, System::Reflection::CallingConventions callingConvention, Type ^ returnType, cli::array <Type ^> ^ parameterTypes, System::Reflection::Module ^ m, bool skipVisibility);

public DynamicMethod (string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, System.Reflection.Module m, bool skipVisibility);

public DynamicMethod (string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, Type returnType, Type[] parameterTypes, System.Reflection.Module m, bool skipVisibility);

new System.Reflection.Emit.DynamicMethod : string * System.Reflection.MethodAttributes * System.Reflection.CallingConventions * Type * Type[] * System.Reflection.Module * bool -> System.Reflection.Emit.DynamicMethod

Public Sub New (name As String, attributes As MethodAttributes, callingConvention As CallingConventions, returnType As Type, parameterTypes As Type(), m As Module, skipVisibility As Boolean)

Parameter

name: String

Der Name der dynamischen Methode. Dies kann eine leere Zeichenfolge sein, sie darf aber nicht null sein.

attributes: MethodAttributes

Eine bitweise Kombination von MethodAttributes-Werten, die die Attribute der dynamischen Methode angibt. Die einzige zulässige Kombination ist Public und Static.

callingConvention: CallingConventions

Die Aufrufkonvention für die dynamische Methode. Muss Standardlauten.

returnType: Type

Ein Type-Objekt, das den Rückgabetyp der dynamischen Methode angibt, oder null, wenn die Methode keinen Rückgabetyp hat.

parameterTypes: Type[]

Ein Array von Type-Objekten, die die Typen der Parameter der dynamischen Methode angeben, oder null, wenn die Methode keine Parameter hat.

m: Module

Ein Module, das das Modul darstellt, dem die dynamische Methode logisch zugeordnet ist.

skipVisibility: Boolean

true, wenn JIT-Sichtbarkeitsprüfungen für Typen und Member übersprungen werden sollen, auf die die MSIL der dynamischen Methode zugreift, andernfalls false.

Ausnahmen

ArgumentException

Ein Element von parameterTypes ist null oder Void.

- oder -

m ist ein Modul, das das anonyme Hosten für dynamische Methoden bereitstellt.

ArgumentNullException

name ist null.

- oder -

m ist null.

NotSupportedException

attributes ist eine Kombination aus Flags außer Public und Static.

- oder -

callingConvention ist nicht Standard.

- oder -

returnType ist ein Typ, für den IsByRef den Wert true zurückgibt.

Hinweise

Die dynamische Methode, die mit diesem Konstruktor erstellt wurde, hat Zugriff auf öffentliche und internal (Friend in Visual Basic) Member aller öffentlichen und internen Typen, die im Modul menthalten sind.

Das Überspringen der Sichtbarkeitsprüfungen des JIT-Compilers ermöglicht es der dynamischen Methode, auf private und geschützte Member aller anderen Typen im Modul und auch in allen anderen Assemblys zuzugreifen. Dies ist z. B. beim Schreiben von Code zum Serialisieren von Objekten nützlich.

Hinweis

Weitere Informationen

Gilt für:

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Quelle:: DynamicMethod.cs

Erstellt eine dynamische Methode. Dabei werden der Methodenname, die Attribute, die Aufrufkonvention, der Rückgabetyp, die Parametertypen und der Typ angegeben, der der dynamischen Methode logisch zugeordnet ist. Außerdem wird angegeben, ob JIT-Sichtbarkeitsprüfungen (Just-In-Time) für Typen und Member übersprungen werden sollen, auf die die MSIL (Microsoft Intermediate Language) der dynamischen Methode zugreift.

public:
 DynamicMethod(System::String ^ name, System::Reflection::MethodAttributes attributes, System::Reflection::CallingConventions callingConvention, Type ^ returnType, cli::array <Type ^> ^ parameterTypes, Type ^ owner, bool skipVisibility);

public DynamicMethod (string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, Type owner, bool skipVisibility);

public DynamicMethod (string name, System.Reflection.MethodAttributes attributes, System.Reflection.CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type owner, bool skipVisibility);

new System.Reflection.Emit.DynamicMethod : string * System.Reflection.MethodAttributes * System.Reflection.CallingConventions * Type * Type[] * Type * bool -> System.Reflection.Emit.DynamicMethod

Public Sub New (name As String, attributes As MethodAttributes, callingConvention As CallingConventions, returnType As Type, parameterTypes As Type(), owner As Type, skipVisibility As Boolean)

Parameter

name: String

Der Name der dynamischen Methode. Dies kann eine leere Zeichenfolge sein, sie darf aber nicht null sein.

attributes: MethodAttributes

Eine bitweise Kombination von MethodAttributes-Werten, die die Attribute der dynamischen Methode angibt. Die einzige zulässige Kombination ist Public und Static.

callingConvention: CallingConventions

Die Aufrufkonvention für die dynamische Methode. Muss Standardlauten.

returnType: Type

Ein Type-Objekt, das den Rückgabetyp der dynamischen Methode angibt, oder null, wenn die Methode keinen Rückgabetyp hat.

parameterTypes: Type[]

Ein Array von Type-Objekten, die die Typen der Parameter der dynamischen Methode angeben, oder null, wenn die Methode keine Parameter hat.

owner: Type

Ein Type, der der dynamischen Methode logisch zugeordnet ist. Die dynamische Methode hat Zugriff auf alle Member des Typs.

skipVisibility: Boolean

true, wenn JIT-Sichtbarkeitsprüfungen für Typen und Member übersprungen werden sollen, auf die die MSIL der dynamischen Methode zugreift, andernfalls false.

Ausnahmen

ArgumentException

Ein Element von parameterTypes ist null oder Void.

- oder -

owner ist eine Schnittstelle, ein Array, ein offener generischer Typ oder ein Typparameter eines generischen Typs oder einer Methode.

ArgumentNullException

name ist null.

- oder -

owner ist null.

NotSupportedException

attributes ist eine Kombination aus Flags außer Public und Static.

- oder -

callingConvention ist nicht Standard.

- oder -

returnType ist ein Typ, für den IsByRef den Wert true zurückgibt.

Hinweise

Die dynamische Methode ist global für das Modul, das den Typ ownerenthält. Sie hat Zugriff auf alle Member des Typs owner.

Die mit diesem Konstruktor erstellte dynamische Methode hat Zugriff auf alle Member des Typs ownerund auf öffentliche und internal (Friend in Visual Basic) Member aller Typen, die in dem Modul enthalten sind, das enthält owner. Wenn Sie die Sichtbarkeitsprüfungen des JIT-Compilers überspringen, kann die dynamische Methode auch auf private und geschützte Member aller anderen Typen zugreifen. Dies ist z. B. beim Schreiben von Code zum Serialisieren von Objekten nützlich.

Hinweis

Aus Gründen der Abwärtskompatibilität erfordert SecurityPermission dieser Konstruktor das SecurityPermissionFlag.ControlEvidence Flag, wenn die folgenden Bedingungen erfüllt sind: owner befindet sich in einem anderen Modul als dem aufrufenden Modul, und die Anforderung für ReflectionPermission mit dem ReflectionPermissionFlag.MemberAccess Flag ist fehlgeschlagen. Wenn die Anforderung erfolgreich SecurityPermission ist, ist der Vorgang zulässig.

Weitere Informationen

Gilt für:

Freigeben über

DynamicMethod Konstruktoren

Definition

Überlädt

DynamicMethod(String, Type, Type[])

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Boolean)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Module)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Type)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Module, Boolean)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

DynamicMethod(String, Type, Type[], Type, Boolean)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen