DynamicMethod Konstruktorok

Definíció

Névtér:: System.Reflection.Emit

Szerelvények:: netstandard.dll, System.Reflection.Emit.Lightweight.dll

Szerelvény:: System.Reflection.Emit.Lightweight.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Dinamikus metódust hoz létre.

Túlterhelések

Name	Description
DynamicMethod(String, Type, Type[])	Inicializál egy névtelenül üzemeltetett dinamikus metódust, megadva a metódus nevét, a visszatérés típusát és a paramétertípusokat.
DynamicMethod(String, Type, Type[], Boolean)	Inicializál egy névtelenül üzemeltetett dinamikus metódust, megadva a metódus nevét, a visszatérési típust, a paramétertípusokat, valamint azt, hogy a dinamikus módszer Microsoft köztes nyelvével (MSIL) elért típusok és tagok esetében kihagyandó-e az igény szerinti (JIT) láthatósági ellenőrzés.
DynamicMethod(String, Type, Type[], Module)	Egy modulra globálisan globális dinamikus metódust hoz létre, amely megadja a metódus nevét, a visszatérés típusát, a paramétertípusokat és a modult.
DynamicMethod(String, Type, Type[], Type)	Létrehoz egy dinamikus metódust, amely megadja a metódus nevét, a visszatérési típust, a paramétertípusokat és azt a típust, amelyhez a dinamikus metódus logikailag társítva van.
DynamicMethod(String, Type, Type[], Module, Boolean)	Egy modulra globálisan globális dinamikus metódust hoz létre, amely megadja a metódus nevét, a visszatérési típust, a paramétertípusokat, a modult, valamint azt, hogy a dinamikus módszer Microsoft köztes nyelve (MSIL) által elért típusok és tagok esetében ki kell-e hagyni az igény szerinti (JIT) láthatósági ellenőrzéseket.
DynamicMethod(String, Type, Type[], Type, Boolean)	Létrehoz egy dinamikus metódust, amely megadja a metódus nevét, a visszatérési típust, a paramétertípusokat, a dinamikus metódus logikai társításának típusát, valamint azt, hogy a dinamikus metódus Microsoft köztes nyelve (MSIL) által elért típusok és tagok esetében kihagyandó-e az időalapú (JIT) láthatósági ellenőrzések.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	Egy modulra globálisan globális dinamikus metódust hoz létre, amely megadja a metódus nevét, attribútumait, hívási konvencióját, visszatérési típusát, paramétertípusait, moduljait, valamint azt, hogy a dinamikus módszer Microsoft köztes nyelve (MSIL) által elért típusok és tagok esetében kihagyandó-e az igény szerinti (JIT) láthatósági ellenőrzések.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	Létrehoz egy dinamikus metódust, amely megadja a metódus nevét, attribútumait, hívási konvencióját, visszatérési típusát, paramétertípusait, a dinamikus metódus logikai társításának típusát, valamint azt, hogy a dinamikus módszer Microsoft köztes nyelvével (MSIL) elért típusok és tagok esetében kihagyandó-e az igény szerinti (JIT) láthatósági ellenőrzések.

DynamicMethod(String, Type, Type[])

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Inicializál egy névtelenül üzemeltetett dinamikus metódust, megadva a metódus nevét, a visszatérés típusát és a paramétertípusokat.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")]
public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes);

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

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

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")>]
new System.Reflection.Emit.DynamicMethod : string * Type * Type[] -> System.Reflection.Emit.DynamicMethod

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

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

Paraméterek

name: String

A dinamikus metódus neve. Ez lehet nulla hosszúságú sztring, de nem lehet null.

returnType: Type

A Type dinamikus metódus visszatérési típusát meghatározó objektum, vagy null ha a metódusnak nincs visszatérési típusa.

parameterTypes: Type[]

Objektumtömb Type , amely megadja a dinamikus metódus paramétereinek típusait, vagy null ha a metódus nem rendelkezik paraméterekkel.

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentException

Az elem parameterTypesnullvagy a Void .

ArgumentNullException

name az null.

NotSupportedException

.NET Framework és .NET Core 2.1-nél régebbi verziói: returnType olyan típus, amelynek IsByReftrue ad vissza.

Megjegyzések

A konstruktor által létrehozott dinamikus metódus egy névtelen szerelvényhez van társítva egy meglévő típus vagy modul helyett. A névtelen szerelvény csak azért létezik, hogy tesztkörnyezetet biztosítson a dinamikus metódusokhoz, azaz elkülönítse őket más kódoktól. Ez a környezet biztonságossá teszi, hogy a dinamikus metódust részben megbízható kóddal lehessen kibocsátani és végrehajtani.

Ez a konstruktor azt határozza meg, hogy a dinamikus módszer Microsoft köztes nyelvére (MSIL) érvényesíteni kell az igény szerinti (JIT) láthatósági ellenőrzéseket. Vagyis a dinamikus metódus kódjának hozzáférése van a nyilvános osztályok nyilvános metódusaihoz. Kivételek akkor jelennek meg, ha a metódus private, protected vagy internal (Friend Visual Basic) típusú vagy tagokat próbál elérni. Ha olyan dinamikus módszert szeretne létrehozni, amely korlátozottan képes kihagyni a JIT láthatósági ellenőrzését, használja a konstruktort DynamicMethod(String, Type, Type[], Boolean) .

Névtelenül üzemeltetett dinamikus metódus létrehozásakor a kibocsátó szerelvény hívásveremét is tartalmazza. A metódus meghívásakor a rendszer a tényleges hívó engedélyei helyett a kibocsátó szerelvény engedélyeit használja. Így a dinamikus metódus nem hajtható végre magasabb jogosultsági szinten, mint az azt kibocsátó szerelvény esetében, még akkor sem, ha azt egy magasabb megbízhatósági szintű szerelvény továbbítja és hajtja végre.

Ez a konstruktor megadja a metódusattribútumokat MethodAttributes.Public és MethodAttributes.Statica hívó konvenciót CallingConventions.Standard.

Note

Ez a konstruktor a .NET Framework 3.5-ös vagy újabb verziójában lett bevezetve.

Lásd még

A következőre érvényes:

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

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Inicializál egy névtelenül üzemeltetett dinamikus metódust, megadva a metódus nevét, a visszatérési típust, a paramétertípusokat, valamint azt, hogy a dinamikus módszer Microsoft köztes nyelvével (MSIL) elért típusok és tagok esetében kihagyandó-e az igény szerinti (JIT) láthatósági ellenőrzés.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")]
public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes, bool restrictedSkipVisibility);

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

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

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")>]
new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * bool -> System.Reflection.Emit.DynamicMethod

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)

Paraméterek

name: String

A dinamikus metódus neve. Ez lehet nulla hosszúságú sztring, de nem lehet null.

returnType: Type

A Type dinamikus metódus visszatérési típusát meghatározó objektum, vagy null ha a metódusnak nincs visszatérési típusa.

parameterTypes: Type[]

Objektumtömb Type , amely megadja a dinamikus metódus paramétereinek típusait, vagy null ha a metódus nem rendelkezik paraméterekkel.

restrictedSkipVisibility: Boolean

truea dinamikus módszer MSIL-jével elért típusok és tagok JIT-láthatósági ellenőrzésének kihagyása ezzel a korlátozással: az ilyen típusokat és tagokat tartalmazó szerelvények megbízhatósági szintjének egyenlőnek vagy kisebbnek kell lennie a dinamikus metódust kibocsátó hívásverem megbízhatósági szintjével; egyéb esetben. false

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentException

Az elem parameterTypesnullvagy a Void .

ArgumentNullException

name az null.

NotSupportedException

.NET Framework és .NET Core 2.1-nél régebbi verziói: returnType olyan típus, amelynek IsByReftrue ad vissza.

Megjegyzések

A névtelenül üzemeltetett dinamikus metódusok nem férnek hozzá automatikusan az private, protected vagy internal (Friend Visual Basic). Ez eltér egy meglévő típushoz vagy modulhoz társított dinamikus metódusoktól, amelyek a társított hatókörük rejtett tagjaihoz rendelkeznek hozzáféréssel.

Adja meg a true-t a restrictedSkipVisibility-hez, ha a dinamikus metódusnak hozzá kell férnie azokhoz a típusokhoz vagy tagokhoz, amelyek private, protected, vagy internal. Ez korlátozott hozzáférést biztosít a dinamikus metódusnak ezekhez a tagokhoz. Vagyis a tagok csak akkor érhetők el, ha az alábbi feltételek teljesülnek:

A céltagok olyan szerelvényhez tartoznak, amelynek megbízhatósági szintje egyenlő vagy alacsonyabb, mint a dinamikus metódust kibocsátó hívásverem.
A dinamikus metódust kibocsátó hívásverem a ReflectionPermission jelölővel lesz megadvaReflectionPermissionFlag.RestrictedMemberAccess. Ez mindig igaz, ha a kód teljes megbízhatósággal van végrehajtva. Részlegesen megbízható kód esetén ez csak akkor igaz, ha a gazdagép kifejezetten megadja az engedélyt.

Important

Ha az engedély nem lett megadva, a rendszer biztonsági kivételt ad ki, amikor CreateDelegate meghívják, vagy amikor a dinamikus metódust meghívja, és nem a konstruktor meghívásakor. A dinamikus metódus kibocsátásához nincs szükség különleges engedélyekre.

Például egy olyan dinamikus metódus, amely úgy restrictedSkipVisibility lett létrehozvatrue, hogy a hívásverem bármely szerelvényének privát tagját elérhesse, ha a hívásverem korlátozott taghozzáférést kapott. Ha a dinamikus metódus részben megbízható kóddal jön létre a hívásveremen, akkor nem fér hozzá egy .NET-keretrendszer-szerelvény egy típusának egy magánszemélyéhez, mert az ilyen szerelvények teljes mértékben megbízhatók.

Ha restrictedSkipVisibilityfalse értéket vesz fel, a JIT láthatósági ellenőrzések érvényesítésre kerülnek. A dinamikus metódus kódjának hozzáférése van a nyilvános osztályok nyilvános metódusaihoz, és kivételeket vált ki, ha olyan típusokhoz vagy tagokhoz próbál hozzáférni, amelyek private, protected vagy internal.

Névtelenül üzemeltetett dinamikus metódus létrehozásakor a kibocsátó szerelvény hívásveremét is tartalmazza. A metódus meghívásakor a rendszer a tényleges hívó engedélyei helyett a kibocsátó hívásverem engedélyeit használja. Így a dinamikus metódus nem hajtható végre magasabb jogosultsági szinten, mint az azt kibocsátó szerelvény esetében, még akkor sem, ha azt egy magasabb megbízhatósági szintű szerelvény továbbítja és hajtja végre.

Ez a konstruktor megadja a metódusattribútumokat MethodAttributes.Public és MethodAttributes.Statica hívó konvenciót CallingConventions.Standard.

Note

Ez a konstruktor a .NET Framework 3.5-ös vagy újabb verziójában lett bevezetve.

Lásd még

A következőre érvényes:

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

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Egy modulra globálisan globális dinamikus metódust hoz létre, amely megadja a metódus nevét, a visszatérés típusát, a paramétertípusokat és a modult.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")]
public DynamicMethod(string name, Type? returnType, 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);

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")>]
new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * System.Reflection.Module -> System.Reflection.Emit.DynamicMethod

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)

Paraméterek

name: String

A dinamikus metódus neve. Ez lehet nulla hosszúságú sztring, de nem lehet null.

returnType: Type

A Type dinamikus metódus visszatérési típusát meghatározó objektum, vagy null ha a metódusnak nincs visszatérési típusa.

parameterTypes: Type[]

Objektumtömb Type , amely megadja a dinamikus metódus paramétereinek típusait, vagy null ha a metódus nem rendelkezik paraméterekkel.

m: Module

Azt Module a modult jelöli, amelyhez a dinamikus metódus logikailag társítható.

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentException

Az elem parameterTypesnullvagy a Void .

-vagy-

m egy modul, amely névtelen üzemeltetést biztosít a dinamikus módszerekhez.

ArgumentNullException

name az null.

-vagy-

m az null.

NotSupportedException

.NET Framework és .NET Core 2.1-nél régebbi verziói: returnType olyan típus, amelynek IsByReftrue ad vissza.

Példák

Az alábbi példakód egy dinamikus metódust hoz létre, amely két paramétert vesz igénybe. A példa egy egyszerű függvénytörzset bocsát ki, amely az első paramétert a konzolra nyomtatja, a példa pedig a második paramétert használja a metódus visszatérési értékeként. A példa egy delegált létrehozásával fejezi be a metódust, meghívja a delegáltat különböző paraméterekkel, és végül meghívja a dinamikus metódust a Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) metódus használatával.

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
'

Megjegyzések

Ez a konstruktor megadja a metódusattribútumokat MethodAttributes.Public és MethodAttributes.Statica hívási konvenciót CallingConventions.Standard, és nem hagyja ki az igény szerinti (JIT) láthatósági ellenőrzéseket.

Az ezzel a konstruktorral létrehozott dinamikus módszer a modulban internaltalálható összes típus nyilvános és Friend (mVisual Basic) tagjaihoz is hozzáfér.

Note

A visszamenőleges kompatibilitás érdekében ez a konstruktor a SecurityPermission jelölővel követeli meg a SecurityPermissionFlag.ControlEvidence-et, ha a következő feltételek teljesülnek: m a hívó modultól eltérő modul, és a ReflectionPermission jelölővel való ReflectionPermissionFlag.MemberAccess igény nem sikeres. Ha a SecurityPermission kérés teljesül, a művelet engedélyezett.

Lásd még

A következőre érvényes:

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

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Létrehoz egy dinamikus metódust, amely megadja a metódus nevét, a visszatérési típust, a paramétertípusokat és azt a típust, amelyhez a dinamikus metódus logikailag társítva van.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")]
public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes, Type owner);

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

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

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")>]
new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * Type -> System.Reflection.Emit.DynamicMethod

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)

Paraméterek

name: String

A dinamikus metódus neve. Ez lehet nulla hosszúságú sztring, de nem lehet null.

returnType: Type

A Type dinamikus metódus visszatérési típusát meghatározó objektum, vagy null ha a metódusnak nincs visszatérési típusa.

parameterTypes: Type[]

Objektumtömb Type , amely megadja a dinamikus metódus paramétereinek típusait, vagy null ha a metódus nem rendelkezik paraméterekkel.

owner: Type

A Type dinamikus metódus logikai társítása. A dinamikus metódus hozzáféréssel rendelkezik a típus összes tagához.

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentException

Az elem parameterTypesnullvagy a Void .

-vagy-

owner egy interfész, egy tömb, egy nyitott általános típus vagy egy általános típus vagy metódus típusparamétere.

ArgumentNullException

name az null.

-vagy-

owner az null.

NotSupportedException

.NET Framework és .NET Core 2.1-nél régebbi verziói: returnType olyan típus, amelynek IsByReftrue ad vissza.

Példák

Az alábbi példakód egy DynamicMethod típushoz logikailag társított típust hoz létre. Ez a társítás hozzáférést biztosít az adott típus magántagjaihoz.

A példakód egy privát mezővel elnevezett Example osztályt határoz meg, egy osztálytDerivedFromExample, amely az első osztályból származik, egy delegált típustUseLikeStatic, amely visszaadja Int32 és típusparaméterekkel Example rendelkezik, valamint Int32egy delegálttípustUseLikeInstance, amely egy adott típusú Int32paramétert ad visszaInt32.

A példakód ezután létrehoz egy DynamicMethod olyan értéket, amely megváltoztatja egy példány Example privát mezőjét, és visszaadja az előző értéket.

Note

Az osztályok belső mezőinek módosítása általában nem jó objektumorientált kódolási gyakorlat.

A példakód létrehozza a(z) Example példányt, majd létrehoz két meghatalmazottat. Az első típus ugyanazokkal UseLikeStatica paraméterekkel rendelkezik, mint a dinamikus metódus. A második típus UseLikeInstance, amely nem rendelkezik az első paraméter (típus Example). Ez a küldött a CreateDelegate(Type, Object) metódus túlterhelésével jön létre; ennek a metódus túlterhelésnek a második paramétere egy Example példány, ebben az esetben az éppen létrehozott példány, amely az újonnan létrehozott delegálthoz van kötve. A delegált meghívásakor a dinamikus metódus a kötött példányon hajtódik végre Example.

Note

Ez egy példa a .NET-keretrendszer 2.0-s verziójában bevezetett delegálási kötés laza szabályaira, valamint a Delegate.CreateDelegate metódus új túlterhelésére. További információért lásd a Delegate osztályt.

A UseLikeStatic meghatalmazott meghívása a meghatalmazotthoz Example kötött példányban UseLikeInstance történik. Ezután a UseLikeInstance delegáltat hívják meg annak érdekében, hogy mindkét delegált ugyanazon a Example példányon működjön. A belső mező értékeinek változásai minden hívás után megjelennek. Végül a UseLikeInstance delegált egy példányhoz van kötve DerivedFromExample, és a delegált hívások ismétlődnek.

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'

Megjegyzések

Note

A visszamenőleges kompatibilitás érdekében ez a SecurityPermission konstruktor megköveteli a SecurityPermissionFlag.ControlEvidence jelölőt, ha a következő feltételek egyszerre teljesülnek: owner egy másik modulban van, mint a hívó modul, és a ReflectionPermission jelölővel kapcsolatos ReflectionPermissionFlag.MemberAccess igény nem teljesült. Ha a SecurityPermission kérés teljesül, a művelet engedélyezett.

Lásd még

A következőre érvényes:

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

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Egy modulra globálisan globális dinamikus metódust hoz létre, amely megadja a metódus nevét, a visszatérési típust, a paramétertípusokat, a modult, valamint azt, hogy a dinamikus módszer Microsoft köztes nyelve (MSIL) által elért típusok és tagok esetében ki kell-e hagyni az igény szerinti (JIT) láthatósági ellenőrzéseket.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")]
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);

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

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")>]
new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * System.Reflection.Module * bool -> System.Reflection.Emit.DynamicMethod

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)

Paraméterek

name: String

A dinamikus metódus neve. Ez lehet nulla hosszúságú sztring, de nem lehet null.

returnType: Type

A Type dinamikus metódus visszatérési típusát meghatározó objektum, vagy null ha a metódusnak nincs visszatérési típusa.

parameterTypes: Type[]

Objektumtömb Type , amely megadja a dinamikus metódus paramétereinek típusait, vagy null ha a metódus nem rendelkezik paraméterekkel.

m: Module

Azt Module a modult jelöli, amelyhez a dinamikus metódus logikailag társítható.

skipVisibility: Boolean

true a dinamikus módszer MSIL által elért típusok és tagok JIT-láthatósági ellenőrzésének kihagyása.

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentException

Az elem parameterTypesnullvagy a Void .

-vagy-

m egy modul, amely névtelen üzemeltetést biztosít a dinamikus módszerekhez.

ArgumentNullException

name az null.

-vagy-

m az null.

NotSupportedException

.NET Framework és .NET Core 2.1-nél régebbi verziói: returnType olyan típus, amelynek IsByReftrue ad vissza.

Megjegyzések

Ez a konstruktor megadja a metódusattribútumokat MethodAttributes.Public és MethodAttributes.Statica hívó konvenciót CallingConventions.Standard.

A konstruktorral létrehozott dinamikus metódus nyilvános és internal (Friend Visual Basic) a m. Ha kihagyja a JIT-fordító láthatósági ellenőrzését, a dinamikus metódus az összes többi típus privát és védett tagjaihoz is hozzáférhet. Ez hasznos lehet például az objektumok szerializálására szolgáló kód írásakor.

Note

Lásd még

A következőre érvényes:

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

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Létrehoz egy dinamikus metódust, amely megadja a metódus nevét, a visszatérési típust, a paramétertípusokat, a dinamikus metódus logikai társításának típusát, valamint azt, hogy a dinamikus metódus Microsoft köztes nyelve (MSIL) által elért típusok és tagok esetében kihagyandó-e az időalapú (JIT) láthatósági ellenőrzések.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")]
public DynamicMethod(string name, Type? returnType, 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);

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")>]
new System.Reflection.Emit.DynamicMethod : string * Type * Type[] * Type * bool -> System.Reflection.Emit.DynamicMethod

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)

Paraméterek

name: String

A dinamikus metódus neve. Ez lehet nulla hosszúságú sztring, de nem lehet null.

returnType: Type

A Type dinamikus metódus visszatérési típusát meghatározó objektum, vagy null ha a metódusnak nincs visszatérési típusa.

parameterTypes: Type[]

Objektumtömb Type , amely megadja a dinamikus metódus paramétereinek típusait, vagy null ha a metódus nem rendelkezik paraméterekkel.

owner: Type

A Type dinamikus metódus logikai társítása. A dinamikus metódus hozzáféréssel rendelkezik a típus összes tagához.

skipVisibility: Boolean

truea dinamikus módszer MSIL-jén keresztül elért típusok és tagok JIT-láthatósági ellenőrzésének kihagyása; egyéb esetben. false

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentException

Az elem parameterTypesnullvagy a Void .

-vagy-

owner egy interfész, egy tömb, egy nyitott általános típus vagy egy általános típus vagy metódus típusparamétere.

ArgumentNullException

name az null.

-vagy-

owner az null.

NotSupportedException

.NET Framework és .NET Core 2.1-nél régebbi verziói: returnType olyan típus, amelynek IsByReftrue ad vissza.

Megjegyzések

Az ezzel a konstruktorral létrehozott dinamikus módszer hozzáféréssel rendelkezik a owner típus összes tagjához, valamint a modulban található összes többi típus nyilvános és internal (Friend Visual Basic) tagjaihoz, ahol a owner található. Ha kihagyja a JIT-fordító láthatósági ellenőrzését, a dinamikus metódus az összes többi típus privát és védett tagjaihoz is hozzáférhet. Ez hasznos lehet például az objektumok szerializálására szolgáló kód írásakor.

Ez a konstruktor megadja a metódusattribútumokat MethodAttributes.Public és MethodAttributes.Statica hívó konvenciót CallingConventions.Standard.

Note

Lásd még

A következőre érvényes:

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

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Egy modulra globálisan globális dinamikus metódust hoz létre, amely megadja a metódus nevét, attribútumait, hívási konvencióját, visszatérési típusát, paramétertípusait, moduljait, valamint azt, hogy a dinamikus módszer Microsoft köztes nyelve (MSIL) által elért típusok és tagok esetében kihagyandó-e az igény szerinti (JIT) láthatósági ellenőrzések.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")]
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);

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

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")>]
new System.Reflection.Emit.DynamicMethod : string * System.Reflection.MethodAttributes * System.Reflection.CallingConventions * Type * Type[] * System.Reflection.Module * bool -> System.Reflection.Emit.DynamicMethod

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)

Paraméterek

name: String

A dinamikus metódus neve. Ez lehet nulla hosszúságú sztring, de nem lehet null.

attributes: MethodAttributes

A dinamikus metódus attribútumait meghatározó értékek bitenkénti kombinációja MethodAttributes . Az egyetlen engedélyezett kombináció az és Publica Static .

callingConvention: CallingConventions

A dinamikus metódus hívási konvenciója. Kell lennie Standard.

returnType: Type

A Type dinamikus metódus visszatérési típusát meghatározó objektum, vagy null ha a metódusnak nincs visszatérési típusa.

parameterTypes: Type[]

Objektumtömb Type , amely megadja a dinamikus metódus paramétereinek típusait, vagy null ha a metódus nem rendelkezik paraméterekkel.

m: Module

Azt Module a modult jelöli, amelyhez a dinamikus metódus logikailag társítható.

skipVisibility: Boolean

truea dinamikus módszer MSIL-jén keresztül elért típusok és tagok JIT-láthatósági ellenőrzésének kihagyása; egyéb esetben. false

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentException

Az elem parameterTypesnullvagy a Void .

-vagy-

m egy modul, amely névtelen üzemeltetést biztosít a dinamikus módszerekhez.

ArgumentNullException

name az null.

-vagy-

m az null.

NotSupportedException

attributesa jelölők kombinációja, amely nem és Publicnem Static .

-vagy-

callingConvention nem Standard.

-vagy-

returnType az a típus, amelynek IsByRef a visszaadása true.

Megjegyzések

Az ezzel a konstruktorral létrehozott dinamikus módszer a internal modulban található összes nyilvános és belső típus nyilvános és Friend (Visual Basic m) tagjaihoz fér hozzá.

Ha kihagyja a JIT-fordító láthatósági ellenőrzését, a dinamikus módszer a modulban és az összes többi szerelvényekben lévő összes többi típus privát és védett tagjaihoz is hozzáférhet. Ez hasznos lehet például az objektumok szerializálására szolgáló kód írásakor.

Note

Lásd még

A következőre érvényes:

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

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Forrás:: DynamicMethod.cs

Létrehoz egy dinamikus metódust, amely megadja a metódus nevét, attribútumait, hívási konvencióját, visszatérési típusát, paramétertípusait, a dinamikus metódus logikai társításának típusát, valamint azt, hogy a dinamikus módszer Microsoft köztes nyelvével (MSIL) elért típusok és tagok esetében kihagyandó-e az igény szerinti (JIT) láthatósági ellenőrzések.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")]
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);

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

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating a DynamicMethod requires dynamic code.")>]
new System.Reflection.Emit.DynamicMethod : string * System.Reflection.MethodAttributes * System.Reflection.CallingConventions * Type * Type[] * Type * bool -> System.Reflection.Emit.DynamicMethod

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)

Paraméterek

name: String

A dinamikus metódus neve. Ez lehet nulla hosszúságú sztring, de nem lehet null.

attributes: MethodAttributes

A dinamikus metódus attribútumait meghatározó értékek bitenkénti kombinációja MethodAttributes . Az egyetlen engedélyezett kombináció az és Publica Static .

callingConvention: CallingConventions

A dinamikus metódus hívási konvenciója. Kell lennie Standard.

returnType: Type

A Type dinamikus metódus visszatérési típusát meghatározó objektum, vagy null ha a metódusnak nincs visszatérési típusa.

parameterTypes: Type[]

Objektumtömb Type , amely megadja a dinamikus metódus paramétereinek típusait, vagy null ha a metódus nem rendelkezik paraméterekkel.

owner: Type

A Type dinamikus metódus logikai társítása. A dinamikus metódus hozzáféréssel rendelkezik a típus összes tagához.

skipVisibility: Boolean

truea dinamikus módszer MSIL-jén keresztül elért típusok és tagok JIT-láthatósági ellenőrzésének kihagyása; egyéb esetben. false

Attribútumok: RequiresDynamicCodeAttribute

Kivételek

ArgumentException

Az elem parameterTypesnullvagy a Void .

-vagy-

owner egy interfész, egy tömb, egy nyitott általános típus vagy egy általános típus vagy metódus típusparamétere.

ArgumentNullException

name az null.

-vagy-

owner az null.

NotSupportedException

attributesa jelölők kombinációja, amely nem és Publicnem Static .

-vagy-

callingConvention nem Standard.

-vagy-

returnType az a típus, amelynek IsByRef a visszaadása true.

Megjegyzések

A dinamikus metódus globális a típust ownertartalmazó modulra. Hozzáféréssel rendelkezik a típus ownerösszes tagához.

Az ezzel a konstruktorral létrehozott dinamikus metódus hozzáfér a owner típusú összes taghoz, valamint a internal-t tartalmazó modulban található összes típus nyilvános és Friend (Visual Basic owner) tagjaihoz. Ha kihagyja a JIT-fordító láthatósági ellenőrzését, a dinamikus metódus az összes többi típus privát és védett tagjaihoz is hozzáférhet. Ez hasznos lehet például az objektumok szerializálására szolgáló kód írásakor.

Note

Lásd még

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?