MethodBuilder Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

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 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	Tento typ se nepodporuje.
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á označuje, zda jsou místní proměnné v této metodě inicializovány nula.
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ě. (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.
IsGenericMethodDefinition	Získá hodnotu označující, zda aktuální MethodBuilder objekt představuje definici obecné metody.
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á chybu NotSupportedException .
IsSecuritySafeCritical	Ve všech případech vyvolá chybu NotSupportedException .
IsSecurityTransparent	Ve všech případech vyvolá chybu NotSupportedException .
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.
MethodHandle	Načte interní popisovač metody. Tento popisovač použijte pro přístup k podkladovému popisovači metadat.
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 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	ParameterInfo Získá objekt, který obsahuje informace o návratového 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

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)
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á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 je daný objekt roven této instanci.
GetBaseDefinition()	Vrátí základní implementaci pro metodu.
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()	ILGenerator Vrátí hodnotu pro tuto metodu s výchozí velikostí streamu MSIL (Microsoft Intermediate Language) o velikosti 64 bajtů.
GetILGenerator(Int32)	Vrátí pro tuto metodu se zadanou ILGenerator velikostí streamu 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.
GetParameters()	Vrátí parametry této metody.
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, kterou tato instance odráží na daném objektu, předáváním zadaných parametrů a pod omezeními daného pořadače.
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.
MakeGenericMethod(Type[])	Vrátí obecnou metodu vytvořenou z aktuální definice obecné metody pomocí zadaných argumentů obecného typu.
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.
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ů.
ToString()	Vrátí tuto MethodBuilder instanci jako řetězec.

Metody rozšíření

GetCustomAttribute(MemberInfo, Type)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena.
GetCustomAttribute(MemberInfo, Type, Boolean)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce tohoto člena.
GetCustomAttribute<T>(MemberInfo)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena.
GetCustomAttribute<T>(MemberInfo, Boolean)	Načte vlastní atribut zadaného typu, který je použit na zadaného člena, a volitelně zkontroluje předchůdce 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é se použijí 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é se použijí na zadaného člena, a volitelně zkontroluje předky tohoto člena.
IsDefined(MemberInfo, Type)	Určuje, zda jsou na zadaného člena použity vlastní atributy zadaného typu.
IsDefined(MemberInfo, Type, Boolean)	Určuje, zda se vlastní atributy zadaného typu použijí na zadaného člena a volitelně se použijí na jeho předky.
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.