Sdílet prostřednictvím


MethodBuilder Třída

Definice

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

public ref class MethodBuilder sealed : System::Reflection::MethodInfo
public ref class MethodBuilder abstract : System::Reflection::MethodInfo
public ref class MethodBuilder sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder
public sealed class MethodBuilder : System.Reflection.MethodInfo
public abstract class MethodBuilder : System.Reflection.MethodInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder
type MethodBuilder = class
    inherit MethodInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder
Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Public MustInherit Class MethodBuilder
Inherits MethodInfo
Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder
Dědičnost
Atributy
Implementuje

Příklady

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

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

void AddMethodDynamically( TypeBuilder^ myTypeBld, 
                           String^ mthdName, 
                           array<Type^>^ mthdParams, 
                           Type^ returnType, 
                           String^ mthdAction )
{
   MethodBuilder^ myMthdBld = myTypeBld->DefineMethod( mthdName, static_cast<MethodAttributes>(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++ )
      {
         if ( mthdAction->Equals( "A" ) )
                  ILOut->Emit( OpCodes::Add );
         else
         if ( mthdAction->Equals( "M" ) )
                  ILOut->Emit( OpCodes::Mul );
         else
                  ILOut->Emit( OpCodes::Add );

      }
   }

   ILOut->Emit( OpCodes::Ret );
};

void main()
{
   AppDomain^ myDomain = AppDomain::CurrentDomain;
   AssemblyName^ asmName = gcnew 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;
   array<String^>^inputNumsList = inputNums->Split();
   array<Type^>^myMthdParams = gcnew array<Type^>(inputNumsList->Length);
   array<Object^>^inputValsList = gcnew array<Object^>(inputNumsList->Length);
   for each (String^ inputNum in inputNumsList)
   {
      inputValsList[ index ] = Convert::ToInt32( inputNum );
      myMthdParams[ index ] = int::typeid;
      index++;
   }

   
   // Now, call the method building method with the parameters, passing the
   // TypeBuilder by reference.
   AddMethodDynamically( myTypeBld, 
                         myMthdName, 
                         myMthdParams, 
                         int::typeid, 
                         myMthdAction );
   Type^ myType = myTypeBld->CreateType();

   Console::WriteLine( "---" );
   Console::WriteLine( "The result of {0} the inputted values is: {1}", 
                       ((myMthdAction->Equals( "M" )) ? "multiplying" : "adding"), 
                       myType->InvokeMember( myMthdName, 
                                             BindingFlags::InvokeMethod | BindingFlags::Public | BindingFlags::Static, 
                       nullptr, 
                       nullptr, 
                       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 );
}

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 najdete v tématu Doplňkové poznámky k rozhraní API pro MethodBuilder.

Konstruktory

MethodBuilder()

Inicializuje novou instanci MethodBuilder třídy .

Vlastnosti

Attributes

Načte atributy pro tuto metodu.

CallingConvention

Vrátí konvenci volání metody .

ContainsGenericParameters

Pro tento typ se nepodporuje.

ContainsGenericParameters

Získá hodnotu, která označuje, zda obecná metoda obsahuje nepřiřazené parametry obecného typu.

(Zděděno od MethodInfo)
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 jsou místní proměnné v této metodě 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á označuje, zda jsou místní proměnné v této metodě inicializovány nulou.

IsAbstract

Získá hodnotu označující, zda je metoda abstraktní.

(Zděděno od MethodBase)
IsAssembly

Získá hodnotu označující, zda potenciální viditelnost této metody nebo konstruktoru je popsána ; Assemblyto znamená, že metoda nebo konstruktor je viditelný maximálně 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 je tento MemberInfo objekt součástí sestavení uchovávaného v collectible AssemblyLoadContext.

(Zděděno od MemberInfo)
IsConstructedGenericMethod

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

IsConstructedGenericMethod

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

(Zděděno od MethodBase)
IsConstructor

Získá hodnotu označující, zda je metoda konstruktor.

(Zděděno od MethodBase)
IsFamily

Získá hodnotu označující, zda viditelnost této metody nebo konstruktoru je popsána ; Familyto 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 označující, zda viditelnost této metody nebo konstruktoru je popsána ; FamANDAssemto znamená, že metoda nebo konstruktor lze volat odvozené třídy, ale pouze pokud jsou ve stejném sestavení.

(Zděděno od MethodBase)
IsFamilyOrAssembly

Získá hodnotu označující, zda potenciální viditelnost této metody nebo konstruktoru je popsána ; FamORAssemto znamená, že metoda nebo konstruktor lze volat odvozené třídy bez ohledu na to, kde jsou, a třídy ve stejném sestavení.

(Zděděno od MethodBase)
IsFinal

Získá hodnotu označující, zda je finaltato metoda .

(Zděděno od MethodBase)
IsGenericMethod

Získá hodnotu označující, zda je metoda obecná metoda.

IsGenericMethod

Získá hodnotu označující, zda aktuální metoda je obecná metoda.

(Zděděno od MethodInfo)
IsGenericMethodDefinition

Získá hodnotu označující, zda aktuální MethodBuilder objekt představuje definici obecné metody.

IsGenericMethodDefinition

Získá hodnotu označující, zda aktuální MethodInfo představuje definici obecné metody.

(Zděděno od MethodInfo)
IsHideBySig

Získá hodnotu označ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 označující, zda je tento člen soukromý.

(Zděděno od MethodBase)
IsPublic

Získá hodnotu označující, zda se jedná o veřejnou metodu.

(Zděděno od MethodBase)
IsSecurityCritical

Ve všech případech vyvolá výjimku NotSupportedException .

IsSecurityCritical

Získá hodnotu, která označuje, zda aktuální metoda nebo konstruktor je na aktuální úrovni důvěryhodnosti kritický nebo bezpečný-kritický na úrovni zabezpečení, a proto může provádět kritické operace.

(Zděděno od MethodBase)
IsSecuritySafeCritical

Ve všech případech vyvolá výjimku NotSupportedException .

IsSecuritySafeCritical

Získá hodnotu, která označuje, zda aktuální metoda nebo konstruktor je zabezpečení-kritické na aktuální úrovni důvěryhodnosti; to znamená, jestli může provádět kritické operace a může být přístupný transparentním kódem.

(Zděděno od MethodBase)
IsSecurityTransparent

Ve všech případech vyvolá výjimku NotSupportedException .

IsSecurityTransparent

Získá hodnotu, která označuje, zda aktuální metoda nebo konstruktor je transparentní na aktuální úrovni důvěryhodnosti, a proto nemůže provádět kritické operace.

(Zděděno od MethodBase)
IsSpecialName

Získá hodnotu označující, zda tato metoda má zvláštní název.

(Zděděno od MethodBase)
IsStatic

Získá hodnotu označující, zda je staticmetoda .

(Zděděno od MethodBase)
IsVirtual

Získá hodnotu označující, zda je virtualmetoda .

(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.

MetadataToken

Získá hodnotu, která identifikuje prvek metadat.

(Zděděno od MemberInfo)
MethodHandle

Načte interní popisovač pro metodu . Tento popisovač použijte pro přístup k podkladovému popisovači metadat.

MethodHandle

Získá popisovač k reprezentaci interních metadat metody.

(Zděděno od MethodBase)
MethodImplementationFlags

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

MethodImplementationFlags

MethodImplAttributes Získá příznaky, které určují atributy implementace metody.

(Zděděno od MethodBase)
Module

Získá modul, ve kterém je aktuální metoda definována.

Module

Získá modul, ve kterém je definován typ, který deklaruje člen reprezentovaný aktuální MemberInfo .

(Zděděno od MemberInfo)
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.

ReflectedType

Získá objekt třídy, který byl použit k získání této instance .MemberInfo

(Zděděno od MemberInfo)
ReturnParameter

ParameterInfo Získá objekt, který obsahuje informace o návratovém typu metody, například zda návratový typ má vlastní modifikátory.

ReturnParameter

ParameterInfo Získá objekt, který obsahuje informace o návratového typu metody, například zda návratový typ má vlastní modifikátory.

(Zděděno od MethodInfo)
ReturnType

Získá návratový typ metody reprezentované tímto MethodBuilder.

ReturnType

Získá návratový typ této metody.

(Zděděno od MethodInfo)
ReturnTypeCustomAttributes

Vrátí vlastní atributy návratového typu metody.

ReturnTypeCustomAttributes

Získá vlastní atributy návratového typu.

(Zděděno od MethodInfo)
Signature

Načte podpis metody .

Metody

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Přidá deklarativní zabezpečení do této metody.

CreateDelegate(Type)

Vytvoří delegáta zadaného typu z této metody.

(Zděděno od MethodInfo)
CreateDelegate(Type, Object)

Vytvoří delegát zadaného typu se zadaným cílem 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)
CreateMethodBody(Byte[], Int32)

Vytvoří tělo metody pomocí zadaného pole bajtů instrukcí jazyka MSIL (Microsoft Intermediate Language).

DefineGenericParameters(String[])

Nastaví počet parametrů obecného typu pro aktuální metodu, určí 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ávratové hodnoty této metody. Vrátí ParametrBuilder, který lze použít vlastní atributy.

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 je daný objekt roven této instanci.

GetBaseDefinition()

Vrátí základní implementaci pro metodu.

GetBaseDefinition()

Při přepsání v odvozené třídě vrátí MethodInfo objekt pro metodu na přímé nebo nepřímé základní třídě, ve které byla metoda reprezentovaná touto instancí poprvé deklarována.

(Zděděno od MethodInfo)
GetCustomAttributes(Boolean)

Vrátí všechny vlastní atributy definované pro tuto metodu.

GetCustomAttributes(Boolean)

Při přepsání v odvozené třídě vrátí pole všech vlastních atributů použitých pro tento člen.

(Zděděno od MemberInfo)
GetCustomAttributes(Type, Boolean)

Vrátí vlastní atributy identifikované daným typem.

GetCustomAttributes(Type, Boolean)

Při přepsání v odvozené třídě vrátí pole vlastních atributů použitých u tohoto člena a identifikovaných pomocí Type.

(Zděděno od MemberInfo)
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á.

GetGenericArguments()

Vrátí pole Type objektů, které představují argumenty typu obecné metody nebo parametry typu definice obecné metody.

(Zděděno od MethodInfo)
GetGenericMethodDefinition()

Vrátí tuto metodu.

GetGenericMethodDefinition()

MethodInfo Vrátí objekt, který představuje obecnou definici metody, ze které lze vytvořit aktuální metodu.

(Zděděno od MethodInfo)
GetHashCode()

Získá kód hash pro tuto metodu.

GetILGenerator()

Vrátí hodnotu ILGenerator pro tuto metodu s výchozí velikostí datového proudu jazyka MSIL (Microsoft Intermediate Language) o velikosti 64 bajtů.

GetILGenerator(Int32)

Vrátí pro tuto metodu se zadanou ILGenerator velikostí streamu jazyka MSIL (Microsoft Intermediate Language).

GetILGeneratorCore(Int32)

Při přepsání v odvozené třídě získá objekt 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 .

GetMethodImplementationFlags()

Při přepsání v odvozené třídě vrátí MethodImplAttributes příznaky.

(Zděděno od MethodBase)
GetModule()

Vrátí odkaz na modul, který obsahuje tuto metodu.

GetParameters()

Vrátí parametry této metody.

GetToken()

Vrátí hodnotu MethodToken , která představuje token pro tuto metodu.

GetType()

Zjistí atributy metody a poskytuje přístup k metadatům metody.

(Zděděno od MethodInfo)
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ý objekt, předává spolu se zadanými parametry a v rámci omezení daného pořadače.

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Při přepsání v odvozené třídě vyvolá odraženou metodu nebo konstruktor s danými parametry.

(Zděděno od MethodBase)
Invoke(Object, Object[])

Vyvolá metodu nebo konstruktor reprezentovaný aktuální instancí pomocí zadaných parametrů.

(Zděděno od MethodInfo)
IsDefined(Type, Boolean)

Zkontroluje, jestli je definovaný typ vlastního atributu.

IsDefined(Type, Boolean)

Při přepsání v odvozené třídě, označuje, zda jeden nebo více atributů zadaného typu nebo jeho odvozených typů je použito na tento člen.

(Zděděno od MemberInfo)
MakeGenericMethod(Type[])

Vrátí obecnou metodu vytvořenou z aktuální definice obecné metody pomocí zadaných argumentů obecného typu.

MakeGenericMethod(Type[])

Nahradí prvky pole typů parametry typu aktuální definice obecné metody a vrátí MethodInfo objekt představující výslednou vytvořenou metodu.

(Zděděno od MethodInfo)
MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(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í vlastního tvůrce atributů.

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

Při přepsání v odvozené třídě nastaví vlastní atribut v tomto 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.

SetMarshal(UnmanagedMarshal)
Zastaralé.

Nastaví informace o zařazování pro návratový typ této metody.

SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)

Vytvoří tělo metody pomocí zadaného pole bajtů instrukcí jazyka MSIL (Microsoft Intermediate Language).

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í signaturu 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í signaturu 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ů.

SetSymCustomAttribute(String, Byte[])

Nastavení symbolického vlastního atributu pomocí objektu blob

ToString()

Vrátí tuto MethodBuilder instanci jako řetězec.

Explicitní implementace rozhraní

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

(Zděděno od MemberInfo)
_MemberInfo.GetType()

Type Získá objekt představující MemberInfo třídu .

(Zděděno od MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.

(Zděděno od MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

(Zděděno od MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

(Zděděno od MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

(Zděděno od MethodBase)
_MethodBase.GetType()

Popis tohoto člena najdete v tématu GetType().

(Zděděno od MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.

(Zděděno od MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

(Zděděno od MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

(Zděděno od MethodBase)
_MethodBase.IsAbstract

Popis tohoto člena najdete v tématu IsAbstract.

(Zděděno od MethodBase)
_MethodBase.IsAssembly

Popis tohoto člena najdete v tématu IsAssembly.

(Zděděno od MethodBase)
_MethodBase.IsConstructor

Popis tohoto člena najdete v tématu IsConstructor.

(Zděděno od MethodBase)
_MethodBase.IsFamily

Popis tohoto člena najdete v tématu IsFamily.

(Zděděno od MethodBase)
_MethodBase.IsFamilyAndAssembly

Popis tohoto člena najdete v tématu IsFamilyAndAssembly.

(Zděděno od MethodBase)
_MethodBase.IsFamilyOrAssembly

Popis tohoto člena najdete v tématu IsFamilyOrAssembly.

(Zděděno od MethodBase)
_MethodBase.IsFinal

Popis tohoto člena najdete v tématu IsFinal.

(Zděděno od MethodBase)
_MethodBase.IsHideBySig

Popis tohoto člena najdete v tématu IsHideBySig.

(Zděděno od MethodBase)
_MethodBase.IsPrivate

Popis tohoto člena najdete v tématu IsPrivate.

(Zděděno od MethodBase)
_MethodBase.IsPublic

Popis tohoto člena najdete v tématu IsPublic.

(Zděděno od MethodBase)
_MethodBase.IsSpecialName

Popis tohoto člena najdete v tématu IsSpecialName.

(Zděděno od MethodBase)
_MethodBase.IsStatic

Popis tohoto člena najdete v tématu IsStatic.

(Zděděno od MethodBase)
_MethodBase.IsVirtual

Popis tohoto člena najdete v tématu IsVirtual.

(Zděděno od MethodBase)
_MethodBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

_MethodBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.

_MethodBuilder.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

_MethodBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.

(Zděděno od MethodInfo)
_MethodInfo.GetType()

Poskytuje přístup k GetType() metodě z modelu COM.

(Zděděno od MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, které lze použít k získání informací o typu pro rozhraní.

(Zděděno od MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).

(Zděděno od MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.

(Zděděno od MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Vrátí pole všech vlastních atributů definovaných v tomto členu, s výjimkou pojmenovaných atributů, nebo prázdné pole, pokud neexistují žádné vlastní atributy.

(Zděděno od MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Vrátí pole vlastních atributů definovaných v tomto členu, identifikované typem nebo prázdné pole, pokud neexistují žádné vlastní atributy tohoto typu.

(Zděděno od MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Určuje, zda je u tohoto člena attributeType definována jedna nebo více instancí.

(Zděděno od MemberInfo)

Metody rozšíření

GetCustomAttribute(MemberInfo, Type)

Načte vlastní atribut zadaného typu, který je použit na zadaný člen.

GetCustomAttribute(MemberInfo, Type, Boolean)

Načte vlastní atribut zadaného typu, který je použit na zadaný člen, a volitelně zkontroluje předky tohoto člena.

GetCustomAttribute<T>(MemberInfo)

Načte vlastní atribut zadaného typu, který je použit na zadaný člen.

GetCustomAttribute<T>(MemberInfo, Boolean)

Načte vlastní atribut zadaného typu, který je použit na zadaný člen, a volitelně zkontroluje předky tohoto člena.

GetCustomAttributes(MemberInfo)

Načte kolekci vlastních atributů, které jsou použity na zadaného člena.

GetCustomAttributes(MemberInfo, Boolean)

Načte kolekci vlastních atributů, které jsou použity na zadaného člena, a volitelně zkontroluje předky tohoto člena.

GetCustomAttributes(MemberInfo, Type)

Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena.

GetCustomAttributes(MemberInfo, Type, Boolean)

Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena, a volitelně zkontroluje předky tohoto člena.

GetCustomAttributes<T>(MemberInfo)

Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena.

GetCustomAttributes<T>(MemberInfo, Boolean)

Načte kolekci vlastních atributů zadaného typu, které jsou použity na zadaného člena, a volitelně zkontroluje předky tohoto člena.

IsDefined(MemberInfo, Type)

Určuje, zda jsou na zadaný člen použity vlastní atributy zadaného typu.

IsDefined(MemberInfo, Type, Boolean)

Určuje, zda vlastní atributy zadaného typu jsou použity na zadaného člena a volitelně použity na jeho nadřazené položky.

GetMetadataToken(MemberInfo)

Získá token metadat pro daného člena, pokud je k dispozici.

HasMetadataToken(MemberInfo)

Vrátí hodnotu, která označuje, zda je token metadat k dispozici pro zadaného člena.

GetBaseDefinition(MethodInfo)

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

GetRuntimeBaseDefinition(MethodInfo)

Načte objekt, který představuje zadanou metodu na přímé nebo nepřímé základní třídě, kde byla metoda poprvé deklarována.

Platí pro