MethodBuilder Třída

Definice

Definuje a představuje metodu (nebo konstruktor) pro dynamickou třídu.Defines and represents a method (or constructor) on a dynamic class.

public ref class MethodBuilder sealed : 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
    interface _MethodBuilder
Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder
Dědičnost
Atributy
Implementuje

Příklady

Následující příklad používá třídu MethodBuilder k vytvoření metody v rámci dynamického typu.The following example uses the MethodBuilder class to create a method within a dynamic type.

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

Třída MethodBuilder slouží k úplnému popisu metody v jazyce MSIL (Microsoft Intermediate Language), včetně názvu, atributů, podpisu a těla metody.The MethodBuilder class is used to fully describe a method in Microsoft intermediate language (MSIL), including the name, attributes, signature, and method body. Používá se ve spojení s TypeBuilder třídou pro vytváření tříd za běhu.It is used in conjunction with the TypeBuilder class to create classes at runtime.

Globální metody a metody jako členy typuGlobal methods and methods as type members

K definování globálních metod a definování metod jako členů typu lze použít metodu emiting reflexe.You can use reflection emit to define global methods and to define methods as type members. Rozhraní API definující metody vrací MethodBuilder objekty.The APIs that define methods return MethodBuilder objects.

Globální metodyGlobal methods

Globální metoda je definována pomocí metody ModuleBuilder.DefineGlobalMethod, která vrací objekt objektu MethodBuilder .A global method is defined by using the ModuleBuilder.DefineGlobalMethod method, which returns a MethodBuilder object.

Globální metody musí být statické.Global methods must be static. Pokud dynamický modul obsahuje globální metody, musí být metoda ModuleBuilder.CreateGlobalFunctions volána před tím, než se uloží dynamický modul nebo obsahující dynamické sestavení, protože modul CLR (Common Language Runtime) odloží opravu dynamického modulu, dokud nebudou všechny globální funkce definované.If a dynamic module contains global methods, the ModuleBuilder.CreateGlobalFunctions method must be called before persisting the dynamic module or the containing dynamic assembly because the common language runtime postpones fixing up the dynamic module until all global functions have been defined.

Globální nativní metoda je definována pomocí metody ModuleBuilder.DefinePInvokeMethod.A global native method is defined by using the ModuleBuilder.DefinePInvokeMethod method. Metody Invoke platformy (PInvoke) nesmí být deklarované jako abstraktní nebo virtuální.Platform invoke (PInvoke) methods must not be declared abstract or virtual. Modul runtime nastavuje atribut MethodAttributes.PinvokeImpl pro metodu Invoke platformy.The runtime sets the MethodAttributes.PinvokeImpl attribute for a platform invoke method.

Metody jako členy typůMethods as members of types

Metoda je definována jako člen typu pomocí metody TypeBuilder.DefineMethod, která vrací objekt MethodBuilder.A method is defined as a type member by using the TypeBuilder.DefineMethod method, which returns a MethodBuilder object.

Metoda DefineParameter slouží k nastavení názvu a atributů parametru parametru nebo návratové hodnoty.The DefineParameter method is used to set the name and parameter attributes of a parameter, or of the return value. Objekt ParameterBuilder vrácený touto metodou představuje parametr nebo vrácenou hodnotu.The ParameterBuilder object returned by this method represents a parameter or the return value. Objekt ParameterBuilder lze použít k nastavení zařazování, k nastavení konstantní hodnoty a k použití vlastních atributů.The ParameterBuilder object can be used to set the marshaling, to set the constant value, and to apply custom attributes.

AtributyAttributes

Členové výčtu MethodAttributes definují přesný znak dynamické metody:Members of the MethodAttributes enumeration define the precise character of a dynamic method:

Známé problémyKnown Issues

Vlastnosti

Attributes

Načte atributy pro tuto metodu.Retrieves the attributes for this method.

CallingConvention

Vrátí konvenci volání metody.Returns the calling convention of the method.

ContainsGenericParameters

Není podporováno pro tento typ.Not supported for this type.

CustomAttributes

Získá kolekci, která obsahuje vlastní atributy tohoto člena.Gets a collection that contains this member's custom attributes.

(Zděděno od MemberInfo)
DeclaringType

Vrátí typ, který deklaruje tuto metodu.Returns the type that declares this method.

InitLocals

Získá nebo nastaví logickou hodnotu, která určuje, zda jsou lokální proměnné v této metodě nulové inicializovány.Gets or sets a Boolean value that specifies whether the local variables in this method are zero initialized. Výchozí hodnota této vlastnosti je true.The default value of this property is true.

IsAbstract

Načte hodnotu, která označuje, jestli je metoda abstraktní.Gets a value indicating whether the method is abstract.

(Zděděno od MethodBase)
IsAssembly

Získá hodnotu, která označuje, zda je potenciální viditelnost této metody nebo konstruktoru 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í.Gets a value indicating whether the potential visibility of this method or constructor is described by Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

(Zděděno od MethodBase)
IsCollectible

Získá hodnotu, která označuje, zda MemberInfo je tento objekt součástí sestavení uloženého ve kolekční. AssemblyLoadContextGets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Zděděno od MemberInfo)
IsConstructedGenericMethod
IsConstructor

Načte hodnotu, která označuje, jestli je metoda konstruktorem.Gets a value indicating whether the method is a constructor.

(Zděděno od MethodBase)
IsFamily

Získá hodnotu, která označuje, zda je tato metoda nebo konstruktor popsána Family. to znamená, že metoda nebo konstruktor je viditelný pouze v rámci své třídy a odvozených tříd.Gets a value indicating whether the visibility of this method or constructor is described by Family; that is, the method or constructor is visible only within its class and derived classes.

(Zděděno od MethodBase)
IsFamilyAndAssembly

Získá hodnotu, která označuje, zda je tato metoda nebo konstruktor popsána FamANDAssem. to znamená, že metodu nebo konstruktor mohou být volány odvozenými třídami, ale pouze v případě, že jsou ve stejném sestavení.Gets a value indicating whether the visibility of this method or constructor is described by FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.

(Zděděno od MethodBase)
IsFamilyOrAssembly

Získá hodnotu, která označuje, zda je potenciální viditelnost této metody nebo konstruktoru popsána FamORAssemhodnotou; to znamená, že metodu nebo konstruktor mohou být volány odvozenými třídami, ať jsou, a třídy ve stejném sestavení.Gets a value indicating whether the potential visibility of this method or constructor is described by FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

(Zděděno od MethodBase)
IsFinal

Načte hodnotu, která označuje, zda je finalTato metoda.Gets a value indicating whether this method is final.

(Zděděno od MethodBase)
IsGenericMethod

Získá hodnotu, která označuje, zda je metoda obecná metoda.Gets a value indicating whether the method is a generic method.

IsGenericMethodDefinition

Získá hodnotu, která označuje, zda aktuální objekt MethodBuilder představuje definici obecné metody.Gets a value indicating whether the current MethodBuilder object represents the definition of a generic method.

IsHideBySig

Získá hodnotu, která označuje, zda je v odvozené třídě skrytý pouze člen stejného typu, který má přesně stejný podpis.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(Zděděno od MethodBase)
IsPrivate

Načte hodnotu, která označuje, jestli je tento člen soukromý.Gets a value indicating whether this member is private.

(Zděděno od MethodBase)
IsPublic

Načte hodnotu, která označuje, zda se jedná o veřejnou metodu.Gets a value indicating whether this is a public method.

(Zděděno od MethodBase)
IsSecurityCritical

Vyvolá NotSupportedException ve všech případech.Throws a NotSupportedException in all cases.

IsSecuritySafeCritical

Vyvolá NotSupportedException ve všech případech.Throws a NotSupportedException in all cases.

IsSecurityTransparent

Vyvolá NotSupportedException ve všech případech.Throws a NotSupportedException in all cases.

IsSpecialName

Načte hodnotu, která označuje, jestli má tato metoda speciální název.Gets a value indicating whether this method has a special name.

(Zděděno od MethodBase)
IsStatic

Načte hodnotu, která označuje, jestli je staticmetoda.Gets a value indicating whether the method is static.

(Zděděno od MethodBase)
IsVirtual

Načte hodnotu, která označuje, jestli je virtualmetoda.Gets a value indicating whether the method is virtual.

(Zděděno od MethodBase)
MemberType

MemberTypes Načte hodnotu, která označuje, že tento člen je metoda.Gets a MemberTypes value indicating that this member is a method.

(Zděděno od MethodInfo)
MetadataToken

Získá hodnotu, která identifikuje element metadat.Gets a value that identifies a metadata element.

(Zděděno od MemberInfo)
MethodHandle

Načte vnitřní popisovač pro metodu.Retrieves the internal handle for the method. Tento popisovač použijte pro přístup k základnímu popisovači metadat.Use this handle to access the underlying metadata handle.

MethodImplementationFlags
Module

Získá modul, ve kterém je definována aktuální metoda.Gets the module in which the current method is being defined.

Name

Načte název této metody.Retrieves the name of this method.

ReflectedType

Načte třídu, která byla použita v reflexi pro získání tohoto objektu.Retrieves the class that was used in reflection to obtain this object.

ReturnParameter

Získá objekt ParameterInfo, který obsahuje informace o návratovém typu metody, například zda návratový typ má vlastní modifikátory.Gets a ParameterInfo object that contains information about the return type of the method, such as whether the return type has custom modifiers.

ReturnType

Získá návratový typ metody reprezentované tímto MethodBuilder.Gets the return type of the method represented by this MethodBuilder.

ReturnTypeCustomAttributes

Vrátí vlastní atributy návratového typu metody.Returns the custom attributes of the method's return type.

Signature

Načte signaturu metody.Retrieves the signature of the method.

Metody

AddDeclarativeSecurity(SecurityAction, PermissionSet)

Přidá k této metodě deklarativní zabezpečení.Adds declarative security to this method.

CreateDelegate(Type)

Vytvoří delegáta zadaného typu z této metody.Creates a delegate of the specified type from this method.

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

Vytvoří delegáta zadaného typu se zadaným cílem z této metody.Creates a delegate of the specified type with the specified target from this method.

(Zděděno od MethodInfo)
CreateMethodBody(Byte[], Int32)

Vytvoří tělo metody pomocí zadaného bajtového pole instrukcí jazyka MSIL (Microsoft Intermediate Language).Creates the body of the method using a supplied byte array of Microsoft intermediate language (MSIL) instructions.

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í omezení.Sets the number of generic type parameters for the current method, specifies their names, and returns an array of GenericTypeParameterBuilder objects that can be used to define their constraints.

DefineParameter(Int32, ParameterAttributes, String)

Nastaví atributy parametru a název parametru této metody nebo vrácenou hodnotu této metody.Sets the parameter attributes and the name of a parameter of this method, or of the return value of this method. Vrátí ParameterBuilder, který lze použít pro použití vlastních atributů.Returns a ParameterBuilder that can be used to apply custom attributes.

Equals(Object)

Určuje, zda je daný objekt stejný jako tato instance.Determines whether the given object is equal to this instance.

GetBaseDefinition()

Vrátí základní implementaci metody.Return the base implementation for a method.

GetCustomAttributes(Boolean)

Vrátí všechny vlastní atributy definované pro tuto metodu.Returns all the custom attributes defined for this method.

GetCustomAttributes(Type, Boolean)

Vrátí vlastní atributy identifikované daným typem.Returns the custom attributes identified by the given type.

GetCustomAttributesData()

Vrátí seznam CustomAttributeData objektů reprezentujících data o atributech, které byly aplikovány na cílového člena.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Zděděno od MemberInfo)
GetGenericArguments()

Vrátí pole objektů GenericTypeParameterBuilder, které reprezentují parametry typu metody, pokud je obecná.Returns an array of GenericTypeParameterBuilder objects that represent the type parameters of the method, if it is generic.

GetGenericMethodDefinition()

Vrátí tuto metodu.Returns this method.

GetHashCode()

Získá kód hodnoty hash pro tuto metodu.Gets the hash code for this method.

GetILGenerator()

Vrátí ILGenerator pro tuto metodu s výchozí velikostí datového proudu jazyka MSIL (Microsoft Intermediate Language) 64 bajtů.Returns an ILGenerator for this method with a default Microsoft intermediate language (MSIL) stream size of 64 bytes.

GetILGenerator(Int32)

Vrátí ILGenerator pro tuto metodu se zadanou velikostí datového proudu jazyka MSIL (Microsoft Intermediate Language).Returns an ILGenerator for this method with the specified Microsoft intermediate language (MSIL) stream size.

GetMethodBody()

Při přepsání v odvozené třídě získá MethodBody objekt, který poskytuje přístup k datovému proudu MSIL, místním proměnným a výjimkám pro aktuální metodu.When overridden in a derived class, gets a MethodBody object that provides access to the MSIL stream, local variables, and exceptions for the current method.

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

Vrátí příznaky implementace pro metodu.Returns the implementation flags for the method.

GetModule()

Vrátí odkaz na modul, který obsahuje tuto metodu.Returns a reference to the module that contains this method.

GetParameters()

Vrátí parametry této metody.Returns the parameters of this method.

GetToken()

Vrátí MethodToken, který představuje token pro tuto metodu.Returns the MethodToken that represents the token for this method.

GetType() (Zděděno od MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Zděděno od MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Dynamicky vyvolá metodu, která se odráží v této instanci na daném objektu, předává se zadaným parametrům a v omezeních daného pořadače.Dynamically invokes the method reflected by this instance on the given object, passing along the specified parameters, and under the constraints of the given binder.

Invoke(Object, Object[]) (Zděděno od MethodInfo)
IsDefined(Type, Boolean)

Kontroluje, zda je definován zadaný typ vlastního atributu.Checks if the specified custom attribute type is defined.

MakeGenericMethod(Type[])

Vrátí obecnou metodu vytvořenou z aktuální definice obecné metody pomocí zadaných argumentů obecného typu.Returns a generic method constructed from the current generic method definition using the specified generic type arguments.

MemberwiseClone()

Vytvoří kopii aktuálního Objectseznamu.Creates a shallow copy of the current Object.

(Zděděno od Object)
SetCustomAttribute(ConstructorInfo, Byte[])

Nastaví vlastní atribut pomocí zadaného objektu BLOB vlastního atributu.Sets a custom attribute using a specified custom attribute blob.

SetCustomAttribute(CustomAttributeBuilder)

Nastaví vlastní atribut pomocí vlastního tvůrce atributů.Sets a custom attribute using a custom attribute builder.

SetImplementationFlags(MethodImplAttributes)

Nastaví pro tuto metodu příznaky implementace.Sets the implementation flags for this method.

SetMarshal(UnmanagedMarshal)

Nastaví zařazovací informace pro návratový typ této metody.Sets marshaling information for the return type of this method.

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

Vytvoří tělo metody pomocí zadaného bajtového pole instrukcí jazyka MSIL (Microsoft Intermediate Language).Creates the body of the method by using a specified byte array of Microsoft intermediate language (MSIL) instructions.

SetParameters(Type[])

Nastaví počet a typy parametrů pro metodu.Sets the number and types of parameters for a method.

SetReturnType(Type)

Nastaví návratový typ metody.Sets the return type of the method.

SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])

Nastaví signaturu metody, včetně návratového typu, typů parametrů a požadované a volitelné modifikátory návratového typu a typů parametrů.Sets the method signature, including the return type, the parameter types, and the required and optional custom modifiers of the return type and parameter types.

SetSymCustomAttribute(String, Byte[])

Nastavte symbolický vlastní atribut pomocí objektu BLOB.Set a symbolic custom attribute using a blob.

ToString()

Vrátí tuto instanci MethodBuilder jako řetězec.Returns this MethodBuilder instance as a string.

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í.Maps a set of names to a corresponding set of dispatch identifiers.

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

Type Získá objektMemberInfo reprezentující třídu.Gets a Type object representing the MemberInfo class.

(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í.Retrieves the type information for an object, which can then be used to get the type information for an interface.

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

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

(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í.Maps a set of names to a corresponding set of dispatch identifiers.

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

Popis tohoto člena naleznete v tématu GetType().For a description of this member, see 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í.Retrieves the type information for an object, which can then be used to get the type information for an interface.

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

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

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

Popis tohoto člena naleznete v tématu IsAbstract.For a description of this member, see IsAbstract.

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

Popis tohoto člena naleznete v tématu IsAssembly.For a description of this member, see IsAssembly.

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

Popis tohoto člena naleznete v tématu IsConstructor.For a description of this member, see IsConstructor.

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

Popis tohoto člena naleznete v tématu IsFamily.For a description of this member, see IsFamily.

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

Popis tohoto člena naleznete v tématu IsFamilyAndAssembly.For a description of this member, see IsFamilyAndAssembly.

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

Popis tohoto člena naleznete v tématu IsFamilyOrAssembly.For a description of this member, see IsFamilyOrAssembly.

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

Popis tohoto člena naleznete v tématu IsFinal.For a description of this member, see IsFinal.

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

Popis tohoto člena naleznete v tématu IsHideBySig.For a description of this member, see IsHideBySig.

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

Popis tohoto člena naleznete v tématu IsPrivate.For a description of this member, see IsPrivate.

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

Popis tohoto člena naleznete v tématu IsPublic.For a description of this member, see IsPublic.

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

Popis tohoto člena naleznete v tématu IsSpecialName.For a description of this member, see IsSpecialName.

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

Popis tohoto člena naleznete v tématu IsStatic.For a description of this member, see IsStatic.

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

Popis tohoto člena naleznete v tématu IsVirtual.For a description of this member, see 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í.Maps a set of names to a corresponding set of dispatch identifiers.

_MethodBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

Načte informace o typu objektu, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can then be used to get the type information for an interface.

_MethodBuilder.GetTypeInfoCount(UInt32)

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

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

Poskytuje přístup k vlastnostem a metodám vystaveným objektem.Provides access to properties and methods exposed by an object.

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

Mapuje sadu názvů na odpovídající sadu identifikátorů pro rozesílání.Maps a set of names to a corresponding set of dispatch identifiers.

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

Poskytuje přístup k GetType() metodě z modelu COM.Provides access to the GetType() method from COM.

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

Načte informace o typu pro objekt, který lze použít k získání informací o typu pro rozhraní.Retrieves the type information for an object, which can be used to get the type information for an interface.

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

Získá počet rozhraní typu informací, které objekt poskytuje (0 nebo 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

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

Metody rozšíření

GetCustomAttribute(MemberInfo, Type)

Načte vlastní atribut zadaného typu, který se použije pro zadaného člena.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

Načte vlastní atribut zadaného typu, který se použije na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

Načte vlastní atribut zadaného typu, který se použije pro zadaného člena.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

Načte vlastní atribut zadaného typu, který se použije na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

Načte kolekci vlastních atributů, které se aplikují na zadaného člena.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

Načte kolekci vlastních atributů, které se aplikují na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Načte kolekci vlastních atributů zadaného typu, které jsou aplikovány na zadaného člena.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

Načte kolekci vlastních atributů zadaného typu, které jsou aplikovány na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

Načte kolekci vlastních atributů zadaného typu, které jsou aplikovány na zadaného člena.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

Načte kolekci vlastních atributů zadaného typu, které jsou aplikovány na zadaného člena, a volitelně zkontroluje nadřazené členy daného člena.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

Určuje, zda jsou pro zadaného člena aplikovány vlastní atributy zadaného typu.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

Označuje, zda jsou vlastní atributy zadaného typu aplikovány na zadaného člena a volitelně také aplikován na jeho nadřazené prvky.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

Získá token metadat pro daného člena, je-li k dispozici.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Vrátí hodnotu, která označuje, zda je pro zadaného člena k dispozici token metadat.Returns a value that indicates whether a metadata token is available for the specified member.

GetBaseDefinition(MethodInfo)
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.Retrieves an object that represents the specified method on the direct or indirect base class where the method was first declared.

Platí pro