MethodBuilder Osztály

Definíció

Névtér:

System.Reflection.Emit

Szerelvények:

netstandard.dll, System.Reflection.Emit.dll

Forrás:

MethodBuilder.cs

Egy dinamikus osztály metódusát (vagy konstruktorát) definiálja és jelöli.

public ref class MethodBuilder abstract : System::Reflection::MethodInfo

public abstract class MethodBuilder : System.Reflection.MethodInfo

type MethodBuilder = class
    inherit MethodInfo

Public MustInherit Class MethodBuilder
Inherits MethodInfo

Öröklődés

Object

MemberInfo

MethodBase

MethodInfo

MethodBuilder

Példák

Az alábbi példa az MethodBuilder osztály használatával hoz létre egy metódust egy dinamikus típuson belül.

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

class DemoMethodBuilder
{
    public static void AddMethodDynamically (TypeBuilder myTypeBld,
                                             string mthdName,
                                             Type[] mthdParams,
                                             Type returnType,
                                             string mthdAction)
    {

        MethodBuilder myMthdBld = myTypeBld.DefineMethod(
                                             mthdName,
                                             MethodAttributes.Public |
                                             MethodAttributes.Static,
                                             returnType,
                                             mthdParams);

        ILGenerator ILout = myMthdBld.GetILGenerator();

        int numParams = mthdParams.Length;

        for (byte x=0; x < numParams; x++)
        {
            ILout.Emit(OpCodes.Ldarg_S, x);
        }

        if (numParams > 1)
        {
            for (int y=0; y<(numParams-1); y++)
            {
                switch (mthdAction)
                {
                    case "A": ILout.Emit(OpCodes.Add);
                              break;
                    case "M": ILout.Emit(OpCodes.Mul);
                              break;
                    default: ILout.Emit(OpCodes.Add);
                              break;
                }
            }
        }
        ILout.Emit(OpCodes.Ret);
    }

    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName asmName = new AssemblyName();
        asmName.Name = "MyDynamicAsm";

        AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                                       asmName,
                                       AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule("MyDynamicAsm",
                                                                  "MyDynamicAsm.dll");

        TypeBuilder myTypeBld = myModule.DefineType("MyDynamicType",
                                                    TypeAttributes.Public);

        // Get info from the user to build the method dynamically.
        Console.WriteLine("Let's build a simple method dynamically!");
        Console.WriteLine("Please enter a few numbers, separated by spaces.");
        string inputNums = Console.ReadLine();
        Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ");
        string myMthdAction = Console.ReadLine().ToUpper();
        Console.Write("Lastly, what do you want to name your new dynamic method? ");
        string myMthdName = Console.ReadLine();

        // Process inputNums into an array and create a corresponding Type array
        int index = 0;
        string[] inputNumsList = inputNums.Split();

        Type[] myMthdParams = new Type[inputNumsList.Length];
        object[] inputValsList = new object[inputNumsList.Length];

        foreach (string inputNum in inputNumsList)
        {
            inputValsList[index] = (object)Convert.ToInt32(inputNum);
                myMthdParams[index] = typeof(int);
                index++;
        }

        // Now, call the method building method with the parameters, passing the
        // TypeBuilder by reference.
        AddMethodDynamically(myTypeBld,
                             myMthdName,
                             myMthdParams,
                             typeof(int),
                             myMthdAction);

        Type myType = myTypeBld.CreateType();

        Console.WriteLine("---");
        Console.WriteLine("The result of {0} the inputted values is: {1}",
                          ((myMthdAction == "M") ? "multiplying" : "adding"),
                          myType.InvokeMember(myMthdName,
                          BindingFlags.InvokeMethod | BindingFlags.Public |
                          BindingFlags.Static,
                          null,
                          null,
                          inputValsList));
        Console.WriteLine("---");

        // Let's take a look at the method we created.
        // If you are interested in seeing the MSIL generated dynamically for the method
        // your program generated, change to the directory where you ran the compiled
        // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
        // of manifest contents appears, click on "MyDynamicType" and then on the name of
        // of the method you provided during execution.

        myAsmBuilder.Save("MyDynamicAsm.dll");

        MethodInfo myMthdInfo = myType.GetMethod(myMthdName);
        Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString());
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Class DemoMethodBuilder
   
   Public Shared Sub AddMethodDynamically(ByVal myTypeBld As TypeBuilder, _
                                          ByVal mthdName As String, _
                                          ByVal mthdParams() As Type, _
                                          ByVal returnType As Type, _
                                          ByVal mthdAction As String)
      
      Dim myMthdBld As MethodBuilder = myTypeBld.DefineMethod(mthdName, _
                                       MethodAttributes.Public Or MethodAttributes.Static, _
                                       returnType, _
                                       mthdParams)
      
      Dim ILout As ILGenerator = myMthdBld.GetILGenerator()
      
      Dim numParams As Integer = mthdParams.Length
      
      Dim x As Byte
      For x = 0 To numParams - 1
         ILout.Emit(OpCodes.Ldarg_S, x)
      Next x
      
      If numParams > 1 Then
         Dim y As Integer
         For y = 0 To (numParams - 1) - 1
            Select Case mthdAction
               Case "A"
                  ILout.Emit(OpCodes.Add)
               Case "M"
                  ILout.Emit(OpCodes.Mul)
               Case Else
                  ILout.Emit(OpCodes.Add)
            End Select
         Next y
      End If
      ILout.Emit(OpCodes.Ret)
   End Sub 
    
   
   Public Shared Sub Main()
      
      Dim myDomain As AppDomain = AppDomain.CurrentDomain
      Dim asmName As New AssemblyName()
      asmName.Name = "MyDynamicAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(asmName, _
                                            AssemblyBuilderAccess.RunAndSave)
      
      Dim myModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyDynamicAsm", _
                                                                       "MyDynamicAsm.dll")
      
      Dim myTypeBld As TypeBuilder = myModule.DefineType("MyDynamicType", TypeAttributes.Public)
      
      ' Get info from the user to build the method dynamically.
      Console.WriteLine("Let's build a simple method dynamically!")
      Console.WriteLine("Please enter a few numbers, separated by spaces.")
      Dim inputNums As String = Console.ReadLine()
      Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ")
      Dim myMthdAction As String = Console.ReadLine().ToUpper()
      Console.Write("Lastly, what do you want to name your new dynamic method? ")
      Dim myMthdName As String = Console.ReadLine()
      
      ' Process inputNums into an array and create a corresponding Type array 
      Dim index As Integer = 0
      Dim inputNumsList As String() = inputNums.Split()
      
      Dim myMthdParams(inputNumsList.Length - 1) As Type
      Dim inputValsList(inputNumsList.Length - 1) As Object
      
      
      Dim inputNum As String
      For Each inputNum In  inputNumsList
         inputValsList(index) = CType(Convert.ToInt32(inputNum), Object)
         myMthdParams(index) = GetType(Integer)
         index += 1
      Next inputNum
      
      ' Now, call the method building method with the parameters, passing the 
      ' TypeBuilder by reference.
      AddMethodDynamically(myTypeBld, myMthdName, myMthdParams, GetType(Integer), myMthdAction)
      
      Dim myType As Type = myTypeBld.CreateType()
     
      Dim description as String 
      If myMthdAction = "M" Then
         description = "multiplying"
      Else
         description = "adding"
      End If

      Console.WriteLine("---")
      Console.WriteLine("The result of {0} the values is: {1}", _
                         description, _
                         myType.InvokeMember(myMthdName, _
                                             BindingFlags.InvokeMethod _
                                               Or BindingFlags.Public _
                                               Or BindingFlags.Static, _
                                             Nothing, _
                                             Nothing, _
                                             inputValsList)) 
      Console.WriteLine("---")

      ' If you are interested in seeing the MSIL generated dynamically for the method
      ' your program generated, change to the directory where you ran the compiled
      ' code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
      ' of manifest contents appears, click on "MyDynamicType" and then on the name of
      ' of the method you provided during execution.
 
      myAsmBuilder.Save("MyDynamicAsm.dll") 

      Dim myMthdInfo As MethodInfo = myType.GetMethod(myMthdName)
      Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString())
   End Sub 
End Class

Megjegyzések

Az API-val kapcsolatos további információkért lásd a MethodBuilder kiegészítő API-megjegyzéseit.

Konstruktorok

Name	Description
MethodBuilder()	Inicializálja a MethodBuilder osztály új példányát.

Tulajdonságok

Name	Description
Attributes	Lekéri a metódus attribútumait.
CallingConvention	A metódus hívási konvencióját adja vissza.
ContainsGenericParameters	Ez a típus nem támogatott.
CustomAttributes	Lekéri a tag egyéni attribútumait tartalmazó gyűjteményt. (Öröklődés forrása MemberInfo)
DeclaringType	Azt a típust adja vissza, amely deklarálja ezt a metódust.
InitLocals	Lekéri vagy beállít egy logikai értéket, amely meghatározza, hogy a metódus helyi változói nulla inicializálva vannak-e. A tulajdonság alapértelmezett értéke true.
InitLocalsCore	Ha egy származtatott osztályban felül van bírálva, lekéri vagy beállít egy értéket, amely jelzi, hogy a metódus helyi változói nulla inicializálva vannak-e.
IsAbstract	Egy értéket kap, amely jelzi, hogy a metódus absztrakt-e. (Öröklődés forrása MethodBase)
IsAssembly	Olyan értéket kap, amely jelzi, hogy a metódus vagy a konstruktor lehetséges láthatóságát az határozza-e meg Assembly, hogy a metódus vagy a konstruktor legfeljebb ugyanazon szerelvény más típusai számára látható, és nem látható a szerelvényen kívüli származtatott típusok számára. (Öröklődés forrása MethodBase)
IsCollectible	Olyan értéket kap, amely jelzi, hogy ez az MemberInfo objektum egy vagy több gyűjteményben tárolt szerelvényre hivatkozik-e AssemblyLoadContext. (Öröklődés forrása MemberInfo)
IsConstructedGenericMethod	Egy dinamikus osztály metódusát (vagy konstruktorát) definiálja és jelöli. (Öröklődés forrása MethodBase)
IsConstructor	Egy értéket kap, amely jelzi, hogy a metódus konstruktor-e. (Öröklődés forrása MethodBase)
IsFamily	Egy értéket kap, amely jelzi, hogy a metódus vagy a konstruktor láthatóságát a rendszer leírja-e Family; vagyis a metódus vagy a konstruktor csak az osztályán belül és a származtatott osztályokban látható. (Öröklődés forrása MethodBase)
IsFamilyAndAssembly	Olyan értéket kap, amely jelzi, hogy a metódus vagy a konstruktor láthatóságát a rendszer leírja-e FamANDAssem; vagyis a metódust vagy a konstruktort származtatott osztályok hívhatják meg, de csak akkor, ha ugyanabban a szerelvényben vannak. (Öröklődés forrása MethodBase)
IsFamilyOrAssembly	Egy értéket kap, amely jelzi, hogy a metódus vagy konstruktor lehetséges láthatóságát a rendszer leírja-e FamORAssem; vagyis a metódust vagy konstruktort származtatott osztályok hívhatják meg, bárhol is vannak, és az ugyanabban a szerelvényben lévő osztályok szerint. (Öröklődés forrása MethodBase)
IsFinal	Egy értéket kap, amely jelzi, hogy ez a metódus .final (Öröklődés forrása MethodBase)
IsGenericMethod	Egy értéket kap, amely jelzi, hogy a metódus általános metódus-e.
IsGenericMethodDefinition	Beolvas egy értéket, amely jelzi, hogy az aktuális MethodBuilder objektum egy általános metódus definícióját jelöli-e.
IsHideBySig	Egy értéket kap, amely azt jelzi, hogy csak egy azonos típusú, pontosan azonos aláírással rendelkező tag van-e elrejtve a származtatott osztályban. (Öröklődés forrása MethodBase)
IsPrivate	Beolvas egy értéket, amely jelzi, hogy ez a tag privát-e. (Öröklődés forrása MethodBase)
IsPublic	Beolvas egy értéket, amely jelzi, hogy ez nyilvános metódus-e. (Öröklődés forrása MethodBase)
IsSecurityCritical	Minden esetben dob.NotSupportedException
IsSecuritySafeCritical	Minden esetben dob.NotSupportedException
IsSecurityTransparent	Minden esetben dob.NotSupportedException
IsSpecialName	Egy értéket kap, amely jelzi, hogy a metódusnak van-e különleges neve. (Öröklődés forrása MethodBase)
IsStatic	Egy értéket kap, amely jelzi, hogy a metódus .static (Öröklődés forrása MethodBase)
IsVirtual	Egy értéket kap, amely jelzi, hogy a metódus .virtual (Öröklődés forrása MethodBase)
MemberType	MemberTypes Egy olyan értéket kap, amely azt jelzi, hogy ez a tag egy metódus. (Öröklődés forrása MethodInfo)
MetadataToken	Lekéri a metaadatokban az aktuális dinamikus modult azonosító jogkivonatot.
MethodHandle	Lekéri a metódus belső fogópontját. Ezzel a leíróval érheti el a mögöttes metaadat-leírót.
MethodImplementationFlags	Lekéri a MethodImplAttributes metódus-implementáció attribútumait meghatározó jelzőket. (Öröklődés forrása MethodBase)
Module	Lekéri azt a modult, amelyben az aktuális metódus definiálva van.
Name	A metódus nevét kéri le.
ReflectedType	Lekéri az objektum lekéréséhez használt osztályt.
ReturnParameter	ParameterInfo Lekéri a metódus visszatérési típusával kapcsolatos információkat tartalmazó objektumot, például azt, hogy a visszatérési típus rendelkezik-e egyéni módosítókkal.
ReturnType	Lekéri a metódus visszatérési típusát.MethodBuilder
ReturnTypeCustomAttributes	A metódus visszatérési típusának egyéni attribútumait adja vissza.

Metódusok

Name	Description
CreateDelegate(Type, Object)	Létrehoz egy megadott típusú delegáltat a metódus megadott céljával. (Öröklődés forrása MethodInfo)
CreateDelegate(Type)	Ezzel a metódussal létrehoz egy megadott típusú meghatalmazottat. (Öröklődés forrása MethodInfo)
CreateDelegate<T>()	Ebből a metódusból létrehoz egy delegáltat T . (Öröklődés forrása MethodInfo)
CreateDelegate<T>(Object)	Létrehoz egy delegáltat T a metódusból a megadott cél használatával. (Öröklődés forrása MethodInfo)
DefineGenericParameters(String[])	Beállítja az aktuális metódus általános típusparamétereinek számát, megadja a nevüket, és egy objektumtömböt GenericTypeParameterBuilder ad vissza, amely a kényszerek meghatározására használható.
DefineGenericParametersCore(String[])	Ha egy származtatott osztályban felül van bírálva, beállítja az aktuális metódus általános típusparamétereinek számát, megadja a nevüket, és egy objektumtömböt GenericTypeParameterBuilder ad vissza, amely a kényszerek meghatározására használható.
DefineParameter(Int32, ParameterAttributes, String)	Beállítja a metódus paraméterattribútumait és egy paraméterének nevét, illetve a metódus visszatérési értékét. Egyéni attribútumok alkalmazásához használható ParameterBuilder értéket ad vissza.
DefineParameterCore(Int32, ParameterAttributes, String)	Ha egy származtatott osztályban felül van bírálva, paramétert vagy visszatérési paramétert határoz meg ehhez a metódushoz.
Equals(Object)	Meghatározza, hogy az adott objektum egyenlő-e ezzel a példánnyal.
GetBaseDefinition()	Adja vissza egy metódus alap implementációjának értékét.
GetCustomAttributes(Boolean)	A metódushoz definiált összes egyéni attribútumot adja vissza.
GetCustomAttributes(Type, Boolean)	Az adott típus által azonosított egyéni attribútumokat adja vissza.
GetCustomAttributesData()	Visszaadja a CustomAttributeData céltagra alkalmazott attribútumok adatait képviselő objektumok listáját. (Öröklődés forrása MemberInfo)
GetGenericArguments()	Olyan objektumtömböt GenericTypeParameterBuilder ad vissza, amely a metódus típusparamétereit jelöli, ha általános.
GetGenericMethodDefinition()	Ezt a metódust adja vissza.
GetHashCode()	Lekéri a metódus kivonatkódját.
GetILGenerator()	Ehhez a metódushoz egy ILGenerator ad vissza, amelynek alapértelmezett Microsoft 64 bájtos köztes nyelvi (MSIL) streammérete.
GetILGenerator(Int32)	Ehhez a metódushoz egy ILGenerator ad vissza a megadott Microsoft köztes nyelv (MSIL) streammérettel.
GetILGeneratorCore(Int32)	Ha felül van bírálva egy származtatott osztályban, olyan értéket ILGenerator kap, amellyel kibocsáthat egy metódustörzset ehhez a metódushoz.
GetMethodBody()	Ha egy származtatott osztályban felül van bírálva, egy MethodBody objektumot kap, amely hozzáférést biztosít az MSIL-adatfolyamhoz, a helyi változókhoz és az aktuális metódus kivételeihez. (Öröklődés forrása MethodBase)
GetMethodImplementationFlags()	A metódus implementálási jelzőit adja vissza.
GetParameters()	A metódus paramétereit adja vissza.
HasSameMetadataDefinitionAs(MemberInfo)	Egy dinamikus osztály metódusát (vagy konstruktorát) definiálja és jelöli. (Öröklődés forrása MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Dinamikusan meghívja a példány által tükrözött metódust az adott objektumon, a megadott paraméterek mentén haladva, az adott kötés kényszerei mellett.
IsDefined(Type, Boolean)	Ellenőrzi, hogy a megadott egyéni attribútumtípus definiálva van-e.
MakeGenericMethod(Type[])	Az aktuális általános metódusdefinícióból létrehozott általános metódust ad vissza a megadott általános típusargumentumok használatával.
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Egyéni attribútum beállítása egy megadott egyéni attribútumblob használatával.
SetCustomAttribute(CustomAttributeBuilder)	Egyéni attribútum beállítása egyéni attribútumszerkesztő használatával.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Ha felül van bírálva egy származtatott osztályban, beállít egy egyéni attribútumot ezen a szerelvényen.
SetImplementationFlags(MethodImplAttributes)	Beállítja a metódus implementálási jelzőit.
SetImplementationFlagsCore(MethodImplAttributes)	Ha egy származtatott osztályban felül van bírálva, beállítja a metódus implementálási jelzőit.
SetParameters(Type[])	Beállítja egy metódus paramétereinek számát és típusait.
SetReturnType(Type)	Beállítja a metódus visszatérési típusát.
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	Beállítja a metódus aláírását, beleértve a visszatérési típust, a paramétertípusokat, valamint a visszatérési típus és a paramétertípusok kötelező és opcionális egyéni módosítóit.
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	Ha egy származtatott osztályban felül van bírálva, beállítja a metódus aláírását, beleértve a visszatérési típust, a paramétertípusokat, valamint a visszatérési típus és a paramétertípusok kötelező és opcionális egyéni módosítóit.
ToString()	Ezt a MethodBuilder példányt sztringként adja vissza.

Bővítő metódusok

Name	Description
GetBaseDefinition(MethodInfo)	Egy dinamikus osztály metódusát (vagy konstruktorát) definiálja és jelöli.
GetCustomAttribute(MemberInfo, Type, Boolean)	Lekéri a megadott típusú egyéni attribútumot, amely egy adott tagra lesz alkalmazva, és opcionálisan az adott tag elődeit vizsgálja meg.
GetCustomAttribute(MemberInfo, Type)	Egy megadott típusú egyéni attribútumot kér le, amelyet egy adott tagra alkalmaz.
GetCustomAttribute<T>(MemberInfo, Boolean)	Lekéri a megadott típusú egyéni attribútumot, amely egy adott tagra lesz alkalmazva, és opcionálisan az adott tag elődeit vizsgálja meg.
GetCustomAttribute<T>(MemberInfo)	Egy megadott típusú egyéni attribútumot kér le, amelyet egy adott tagra alkalmaz.
GetCustomAttributes(MemberInfo, Boolean)	Lekéri a megadott tagra alkalmazott egyéni attribútumok gyűjteményét, és opcionálisan az adott tag őseit vizsgálja meg.
GetCustomAttributes(MemberInfo, Type, Boolean)	Lekéri a megadott típusú egyéni attribútumok gyűjteményét, amelyek egy adott tagra vonatkoznak, és opcionálisan az adott tag elődeit is érintik.
GetCustomAttributes(MemberInfo, Type)	Egy megadott típusú egyéni attribútumok gyűjteményét kéri le, amelyeket egy adott tagra alkalmaz.
GetCustomAttributes(MemberInfo)	Egy adott tagra alkalmazott egyéni attribútumok gyűjteményét kéri le.
GetCustomAttributes<T>(MemberInfo, Boolean)	Lekéri a megadott típusú egyéni attribútumok gyűjteményét, amelyek egy adott tagra vonatkoznak, és opcionálisan az adott tag elődeit is érintik.
GetCustomAttributes<T>(MemberInfo)	Egy megadott típusú egyéni attribútumok gyűjteményét kéri le, amelyeket egy adott tagra alkalmaz.
GetMetadataToken(MemberInfo)	Ha elérhető, lekéri az adott tag metaadat-jogkivonatát.
GetRuntimeBaseDefinition(MethodInfo)	Egy objektumot kér le, amely a megadott metódust jelöli azon a közvetlen vagy közvetett alaposztályon, ahol a metódus először deklarálva lett.
HasMetadataToken(MemberInfo)	Olyan értéket ad vissza, amely jelzi, hogy elérhető-e metaadat-jogkivonat a megadott tag számára.
IsDefined(MemberInfo, Type, Boolean)	Azt jelzi, hogy a megadott típusú egyéni attribútumok alkalmazhatók-e egy adott tagra, és szükség esetén alkalmazva vannak-e az elődökre.
IsDefined(MemberInfo, Type)	Azt jelzi, hogy a megadott típusú egyéni attribútumok alkalmazhatók-e egy adott tagra.