MethodBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

netstandard.dll, System.Reflection.Emit.dll

Zdroj:

MethodBuilder.cs

Definuje a představuje metodu (nebo konstruktor) v dynamické třídě.

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

Dědičnost

Object

MemberInfo

MethodBase

MethodInfo

MethodBuilder

Příklady

Následující příklad používá MethodBuilder třídu k vytvoření metody v rámci dynamického typu.

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

Poznámky

Další informace o tomto rozhraní API naleznete v tématu Doplňkové poznámky k rozhraní API pro MethodBuilder.

Konstruktory

Name	Description
MethodBuilder()	Inicializuje novou instanci MethodBuilder třídy.

Vlastnosti

Name	Description
Attributes	Načte atributy pro tuto metodu.
CallingConvention	Vrátí konvenci volání metody.
ContainsGenericParameters	Tento typ není podporován.
CustomAttributes	Získá kolekci, která obsahuje vlastní atributy tohoto člena. (Zděděno od MemberInfo)
DeclaringType	Vrátí typ, který deklaruje tuto metodu.
InitLocals	Získá nebo nastaví logickou hodnotu, která určuje, zda místní proměnné v této metodě jsou inicializovány nula. Výchozí hodnota této vlastnosti je true.
InitLocalsCore	Při přepsání v odvozené třídě získá nebo nastaví hodnotu, která určuje, zda místní proměnné v této metodě jsou inicializovány nulou.
IsAbstract	Získá hodnotu určující, zda metoda je abstraktní. (Zděděno od MethodBase)
IsAssembly	Získá hodnotu určující, zda potenciální viditelnost této metody nebo konstruktoru je popsána Assembly; to znamená, že metoda nebo konstruktor je viditelná nejvýše pro jiné typy ve stejném sestavení a není viditelná pro odvozené typy mimo sestavení. (Zděděno od MethodBase)
IsCollectible	Získá hodnotu, která označuje, zda tento MemberInfo objekt odkazuje na jedno nebo více sestavení uložených v collectible AssemblyLoadContext. (Zděděno od MemberInfo)
IsConstructedGenericMethod	Definuje a představuje metodu (nebo konstruktor) v dynamické třídě. (Zděděno od MethodBase)
IsConstructor	Získá hodnotu určující, zda metoda je konstruktor. (Zděděno od MethodBase)
IsFamily	Získá hodnotu určující, zda viditelnost této metody nebo konstruktoru je popsána Family; to znamená, že metoda nebo konstruktor je viditelná pouze v rámci své třídy a odvozené třídy. (Zděděno od MethodBase)
IsFamilyAndAssembly	Získá hodnotu určující, zda viditelnost této metody nebo konstruktoru je popsána FamANDAssem; to znamená, že metoda nebo konstruktor lze volat odvozenými třídami, ale pouze pokud jsou ve stejném sestavení. (Zděděno od MethodBase)
IsFamilyOrAssembly	Získá hodnotu určující, zda potenciální viditelnost této metody nebo konstruktoru je popsána FamORAssem; to znamená, že metoda nebo konstruktor lze volat odvozenými třídami bez ohledu na to, kde jsou, a třídami ve stejném sestavení. (Zděděno od MethodBase)
IsFinal	Získá hodnotu určující, zda tato metoda je final. (Zděděno od MethodBase)
IsGenericMethod	Získá hodnotu určující, zda metoda je obecná metoda.
IsGenericMethodDefinition	Získá hodnotu určující, zda aktuální MethodBuilder objekt představuje definici obecné metody.
IsHideBySig	Získá hodnotu určující, zda je v odvozené třídě skrytý pouze člen stejného typu s přesně stejným podpisem. (Zděděno od MethodBase)
IsPrivate	Získá hodnotu určující, zda je tento člen soukromý. (Zděděno od MethodBase)
IsPublic	Získá hodnotu určující, zda je to veřejná metoda. (Zděděno od MethodBase)
IsSecurityCritical	Vyvolá výjimku NotSupportedException ve všech případech.
IsSecuritySafeCritical	Vyvolá výjimku NotSupportedException ve všech případech.
IsSecurityTransparent	Vyvolá výjimku NotSupportedException ve všech případech.
IsSpecialName	Získá hodnotu označující, zda tato metoda má speciální název. (Zděděno od MethodBase)
IsStatic	Získá hodnotu určující, zda metoda je static. (Zděděno od MethodBase)
IsVirtual	Získá hodnotu určující, zda metoda je virtual. (Zděděno od MethodBase)
MemberType	MemberTypes Získá hodnotu označující, že tento člen je metoda. (Zděděno od MethodInfo)
MetadataToken	Získá token, který identifikuje aktuální dynamický modul v metadatech.
MethodHandle	Načte interní popisovač metody. Tento popisovač použijte pro přístup k podkladovému popisovači metadat.
MethodImplementationFlags	Získá MethodImplAttributes příznaky, které určují atributy implementace metody. (Zděděno od MethodBase)
Module	Získá modul, ve kterém je definována aktuální metoda.
Name	Načte název této metody.
ReflectedType	Načte třídu, která byla použita v reflexi k získání tohoto objektu.
ReturnParameter	Získá ParameterInfo objekt, který obsahuje informace o návratovém typu metody, například zda návratový typ má vlastní modifikátory.
ReturnType	Získá návratový typ metody reprezentované tímto MethodBuilder.
ReturnTypeCustomAttributes	Vrátí vlastní atributy návratového typu metody.

Metody

Name	Description
CreateDelegate(Type, Object)	Vytvoří delegáta zadaného typu se zadaným cílem z této metody. (Zděděno od MethodInfo)
CreateDelegate(Type)	Vytvoří delegáta zadaného typu z této metody. (Zděděno od MethodInfo)
CreateDelegate<T>()	Vytvoří delegáta typu T z této metody. (Zděděno od MethodInfo)
CreateDelegate<T>(Object)	Vytvoří delegáta typu T se zadaným cílem z této metody. (Zděděno od MethodInfo)
DefineGenericParameters(String[])	Nastaví počet parametrů obecného typu pro aktuální metodu, určuje jejich názvy a vrátí pole GenericTypeParameterBuilder objektů, které lze použít k definování jejich omezení.
DefineGenericParametersCore(String[])	Při přepsání v odvozené třídě nastaví počet parametrů obecného typu pro aktuální metodu, určuje jejich názvy a vrátí pole GenericTypeParameterBuilder objektů, které lze použít k definování jejich omezení.
DefineParameter(Int32, ParameterAttributes, String)	Nastaví atributy parametru a název parametru této metody nebo návratovou hodnotu této metody. Vrátí parametrBuilder, který lze použít k použití vlastních atributů.
DefineParameterCore(Int32, ParameterAttributes, String)	Při přepsání v odvozené třídě definuje parametr nebo návratový parametr pro tuto metodu.
Equals(Object)	Určuje, zda se daný objekt rovná této instanci.
GetBaseDefinition()	Vrátí základní implementaci metody.
GetCustomAttributes(Boolean)	Vrátí všechny vlastní atributy definované pro tuto metodu.
GetCustomAttributes(Type, Boolean)	Vrátí vlastní atributy identifikované daným typem.
GetCustomAttributesData()	Vrátí seznam CustomAttributeData objektů představujících data o atributech, které byly použity na cílového člena. (Zděděno od MemberInfo)
GetGenericArguments()	Vrátí pole GenericTypeParameterBuilder objektů, které představují parametry typu metody, pokud je obecný.
GetGenericMethodDefinition()	Vrátí tuto metodu.
GetHashCode()	Získá hash kód pro tuto metodu.
GetILGenerator()	Vrátí ILGenerator pro tuto metodu s výchozí velikostí datového proudu jazyka MSIL (Microsoft intermediate language) o velikosti 64 bajtů.
GetILGenerator(Int32)	Vrátí ILGenerator pro tuto metodu se zadanou velikostí datového proudu jazyka MSIL (Microsoft intermediate language).
GetILGeneratorCore(Int32)	Při přepsání v odvozené třídě získá ILGenerator , který lze použít k vygenerování těla metody pro tuto metodu.
GetMethodBody()	Při přepsání v odvozené třídě získá MethodBody objekt, který poskytuje přístup k msIL stream, místní proměnné a výjimky pro aktuální metodu. (Zděděno od MethodBase)
GetMethodImplementationFlags()	Vrátí příznaky implementace pro metodu.
GetParameters()	Vrátí parametry této metody.
HasSameMetadataDefinitionAs(MemberInfo)	Definuje a představuje metodu (nebo konstruktor) v dynamické třídě. (Zděděno od MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Dynamicky vyvolá metodu reflektovanou touto instancí na daném objektu, předávání zadaných parametrů a v rámci omezení daného pořadače.
IsDefined(Type, Boolean)	Zkontroluje, jestli je definovaný zadaný typ vlastního atributu.
MakeGenericMethod(Type[])	Vrátí obecnou metodu sestavenou z aktuální definice obecné metody pomocí zadaných argumentů obecného typu.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Nastaví vlastní atribut pomocí zadaného objektu blob vlastního atributu.
SetCustomAttribute(CustomAttributeBuilder)	Nastaví vlastní atribut pomocí tvůrce vlastních atributů.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě nastaví vlastní atribut pro toto sestavení.
SetImplementationFlags(MethodImplAttributes)	Nastaví příznaky implementace pro tuto metodu.
SetImplementationFlagsCore(MethodImplAttributes)	Při přepsání v odvozené třídě nastaví příznaky implementace pro tuto metodu.
SetParameters(Type[])	Nastaví počet a typy parametrů pro metodu.
SetReturnType(Type)	Nastaví návratový typ metody.
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	Nastaví podpis metody, včetně návratového typu, typů parametrů a požadovaných a volitelných vlastních modifikátorů návratového typu a typů parametrů.
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	Při přepsání v odvozené třídě nastaví podpis metody, včetně návratového typu, typů parametrů a povinných a volitelných vlastních modifikátorů návratového typu a typů parametrů.
ToString()	Vrátí tuto MethodBuilder instanci jako řetězec.

Metody rozšíření

Name	Description
GetBaseDefinition(MethodInfo)	Definuje a představuje metodu (nebo konstruktor) v dynamické třídě.
GetCustomAttribute(MemberInfo, Type, Boolean)	Načte vlastní atribut zadaného typu, který se použije u zadaného členu, a volitelně zkontroluje předky daného člena.
GetCustomAttribute(MemberInfo, Type)	Načte vlastní atribut zadaného typu, který se použije na zadaný člen.
GetCustomAttribute<T>(MemberInfo, Boolean)	Načte vlastní atribut zadaného typu, který se použije u zadaného členu, a volitelně zkontroluje předky daného člena.
GetCustomAttribute<T>(MemberInfo)	Načte vlastní atribut zadaného typu, který se použije na zadaný člen.
GetCustomAttributes(MemberInfo, Boolean)	Načte kolekci vlastních atributů, které se použijí na zadaného člena, a volitelně zkontroluje předky daného člena.
GetCustomAttributes(MemberInfo, Type, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen, a volitelně zkontroluje nadřazené objekty daného člena.
GetCustomAttributes(MemberInfo, Type)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen.
GetCustomAttributes(MemberInfo)	Načte kolekci vlastních atributů, které se použijí na zadaný člen.
GetCustomAttributes<T>(MemberInfo, Boolean)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen, a volitelně zkontroluje nadřazené objekty daného člena.
GetCustomAttributes<T>(MemberInfo)	Načte kolekci vlastních atributů zadaného typu, které se použijí na zadaný člen.
GetMetadataToken(MemberInfo)	Získá token metadat pro daného člena, pokud je k dispozici.
GetRuntimeBaseDefinition(MethodInfo)	Načte objekt, který představuje zadanou metodu pro přímou nebo nepřímou základní třídu, kde byla metoda poprvé deklarována.
HasMetadataToken(MemberInfo)	Vrátí hodnotu, která určuje, zda je token metadat k dispozici pro zadaného člena.
IsDefined(MemberInfo, Type, Boolean)	Určuje, zda se vlastní atributy zadaného typu použijí na zadaný člen a volitelně se použijí na jeho nadřazené objekty.
IsDefined(MemberInfo, Type)	Určuje, zda jsou u zadaného člena použity vlastní atributy zadaného typu.