MethodBuilder Sınıf

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kod:

System.Reflection.Emit.dll

Kaynak:

MethodBuilder.cs

Dinamik sınıftaki bir yöntemi (veya oluşturucuyu) tanımlar ve temsil eder.

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

Devralma

Object

MemberInfo

MethodBase

MethodInfo

MethodBuilder

Örnekler

Aşağıdaki örnek, dinamik bir tür içinde bir yöntem oluşturmak için sınıfını MethodBuilder kullanır.

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

Açıklamalar

Bu API hakkında daha fazla bilgi için bkz . MethodBuilder için ek API açıklamaları.

Oluşturucular

MethodBuilder()

MethodBuilder sınıfının yeni bir örneğini başlatır.

Özellikler

Attributes	Bu yöntemin özniteliklerini alır.
CallingConvention	yönteminin çağırma kuralını döndürür.
ContainsGenericParameters	Bu tür için desteklenmez.
CustomAttributes	Bu üyenin özel özniteliklerini içeren bir koleksiyon alır. (Devralındığı yer: MemberInfo)
DeclaringType	Bu yöntemi bildiren türü döndürür.
InitLocals	Bu yöntemdeki yerel değişkenlerin sıfır başlatılıp başlatılmadığını belirten bir Boole değeri alır veya ayarlar. Bu özelliğin varsayılan değeri şeklindedir true.
InitLocalsCore	Türetilmiş bir sınıfta geçersiz kılındığında, bu yöntemdeki yerel değişkenlerin sıfır başlatılıp başlatılmadığını belirten bir değer alır veya ayarlar.
IsAbstract	Yöntemin soyut olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsAssembly	Bu yöntemin veya oluşturucunun olası görünürlüğünün ile Assemblyaçıklanıp açıklanmadığını belirten bir değer alır; başka bir deyişle, yöntem veya oluşturucu aynı derlemedeki diğer türler için en fazla görünürdür ve derleme dışındaki türetilmiş türler tarafından görünmez. (Devralındığı yer: MethodBase)
IsCollectible	Bu MemberInfo nesnenin toplanabilir AssemblyLoadContextbir derlemenin parçası olup olmadığını gösteren bir değer alır. (Devralındığı yer: MemberInfo)
IsConstructedGenericMethod	Dinamik sınıftaki bir yöntemi (veya oluşturucuyu) tanımlar ve temsil eder. (Devralındığı yer: MethodBase)
IsConstructor	Yöntemin bir oluşturucu olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsFamily	Bu yöntemin veya oluşturucunun görünürlüğünün tarafından Familyaçıklanıp tanımlanmadığını belirten bir değer alır; başka bir ifadeyle, yöntem veya oluşturucu yalnızca kendi sınıfı ve türetilmiş sınıfları içinde görünür. (Devralındığı yer: MethodBase)
IsFamilyAndAssembly	Bu yöntemin veya oluşturucunun görünürlüğünün tarafından FamANDAssemaçıklanıp tanımlanmadığını belirten bir değer alır; başka bir ifadeyle, yöntem veya oluşturucu türetilmiş sınıflar tarafından çağrılabilir, ancak yalnızca aynı derlemedeyseler. (Devralındığı yer: MethodBase)
IsFamilyOrAssembly	Bu yöntemin veya oluşturucunun olası görünürlüğünün ile FamORAssemaçıklanıp açıklanmadığını belirten bir değer alır; başka bir ifadeyle, yöntem veya oluşturucu nerede olurlarsa olsunlar türetilmiş sınıflar tarafından ve aynı derlemedeki sınıflar tarafından çağrılabilir. (Devralındığı yer: MethodBase)
IsFinal	Bu yöntemin finalolup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsGenericMethod	Yöntemin genel bir yöntem olup olmadığını belirten bir değer alır.
IsGenericMethodDefinition	Geçerli MethodBuilder nesnenin genel bir yöntemin tanımını temsil edip etmediğini belirten bir değer alır.
IsHideBySig	Türetilmiş sınıfta yalnızca aynı türdeki aynı imzaya sahip bir üyenin gizlenip gizlenmediğini belirten bir değer alır. (Devralındığı yer: MethodBase)
IsPrivate	Bu üyenin özel olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsPublic	Bunun genel bir yöntem olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsSecurityCritical	Her durumda bir NotSupportedException atar.
IsSecuritySafeCritical	Her durumda bir NotSupportedException atar.
IsSecurityTransparent	Her durumda bir NotSupportedException atar.
IsSpecialName	Bu yöntemin özel bir ada sahip olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsStatic	yönteminin staticolup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsVirtual	yönteminin virtualolup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
MemberType	Bu üyenin bir MemberTypes yöntem olduğunu belirten bir değer alır. (Devralındığı yer: MethodInfo)
MetadataToken	Meta verilerdeki geçerli dinamik modülü tanımlayan bir belirteç alır.
MethodHandle	yöntemi için iç tanıtıcıyı alır. Temel alınan meta veri tanıtıcısına erişmek için bu tanıtıcıyı kullanın.
MethodImplementationFlags	MethodImplAttributes Bir yöntem uygulamasının özniteliklerini belirten bayrakları alır. (Devralındığı yer: MethodBase)
Module	Geçerli yöntemin tanımlandığı modülü alır.
Name	Bu yöntemin adını alır.
ReflectedType	Bu nesneyi almak için yansımada kullanılan sınıfını alır.
ReturnParameter	Dönüş türünün özel değiştiricileri olup olmadığı gibi yöntemin dönüş türü hakkında bilgi içeren bir ParameterInfo nesnesi alır.
ReturnType	Bu MethodBuildertarafından temsil edilen yöntemin dönüş türünü alır.
ReturnTypeCustomAttributes	Yöntemin dönüş türünün özel özniteliklerini döndürür.

Yöntemler

CreateDelegate(Type)	Bu yöntemden belirtilen türde bir temsilci oluşturur. (Devralındığı yer: MethodInfo)
CreateDelegate(Type, Object)	Bu yöntemden belirtilen hedefle belirtilen türde bir temsilci oluşturur. (Devralındığı yer: MethodInfo)
CreateDelegate<T>()	Bu yöntemden türünde T bir temsilci oluşturur. (Devralındığı yer: MethodInfo)
CreateDelegate<T>(Object)	Bu yöntemden belirtilen hedefle türünde T bir temsilci oluşturur. (Devralındığı yer: MethodInfo)
DefineGenericParameters(String[])	Geçerli yöntem için genel tür parametrelerinin sayısını ayarlar, adlarını belirtir ve kısıtlamalarını tanımlamak için kullanılabilecek bir nesne dizisi GenericTypeParameterBuilder döndürür.
DefineGenericParametersCore(String[])	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli yöntem için genel tür parametrelerinin sayısını ayarlar, adlarını belirtir ve kısıtlamalarını tanımlamak için kullanılabilecek bir nesne dizisi GenericTypeParameterBuilder döndürür.
DefineParameter(Int32, ParameterAttributes, String)	Parametre özniteliklerini ve bu yöntemin bir parametresinin adını veya bu yöntemin dönüş değerini ayarlar. Özel öznitelikleri uygulamak için kullanılabilecek bir ParameterBuilder döndürür.
DefineParameterCore(Int32, ParameterAttributes, String)	Türetilmiş bir sınıfta geçersiz kılındığında, bu yöntem için bir parametre veya dönüş parametresi tanımlar.
Equals(Object)	Verilen nesnenin bu örneğe eşit olup olmadığını belirler.
GetBaseDefinition()	Bir yöntem için temel uygulamayı döndürür.
GetCustomAttributes(Boolean)	Bu yöntem için tanımlanan tüm özel öznitelikleri döndürür.
GetCustomAttributes(Type, Boolean)	Verilen tür tarafından tanımlanan özel öznitelikleri döndürür.
GetCustomAttributesData()	Hedef üyeye CustomAttributeData uygulanmış özniteliklerle ilgili verileri temsil eden nesnelerin listesini döndürür. (Devralındığı yer: MemberInfo)
GetGenericArguments()	Genelse yönteminin GenericTypeParameterBuilder tür parametrelerini temsil eden bir nesne dizisi döndürür.
GetGenericMethodDefinition()	Bu yöntemi döndürür.
GetHashCode()	Bu yöntemin karma kodunu alır.
GetILGenerator()	Varsayılan Microsoft ara dili (MSIL) akış boyutu 64 bayt olan bu yöntem için bir ILGenerator döndürür.
GetILGenerator(Int32)	Belirtilen Microsoft ara dili (MSIL) akış boyutuna sahip bu yöntem için bir ILGenerator döndürür.
GetILGeneratorCore(Int32)	Türetilmiş bir sınıfta geçersiz kılındığında, bu yöntemin yöntem gövdesini yaymak için kullanılabilecek bir alır ILGenerator .
GetMethodBody()	Türetilmiş bir sınıfta geçersiz kılındığında, MSIL akışına, yerel değişkenlere ve geçerli yöntem için özel durumlara erişim sağlayan bir MethodBody nesnesi alır. (Devralındığı yer: MethodBase)
GetMethodImplementationFlags()	yöntemi için uygulama bayraklarını döndürür.
GetParameters()	Bu yöntemin parametrelerini döndürür.
GetType()	Bir yöntemin özniteliklerini bulur ve yöntem meta verilerine erişim sağlar. (Devralındığı yer: MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Dinamik sınıftaki bir yöntemi (veya oluşturucuyu) tanımlar ve temsil eder. (Devralındığı yer: MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Belirtilen parametreler boyunca ve verilen bağlayıcının kısıtlamaları altında geçirerek verilen nesnede bu örnek tarafından yansıtılan yöntemi dinamik olarak çağırır.
Invoke(Object, Object[])	Belirtilen parametreleri kullanarak geçerli örnek tarafından temsil edilen yöntemi veya oluşturucuyu çağırır. (Devralındığı yer: MethodInfo)
IsDefined(Type, Boolean)	Belirtilen özel öznitelik türünün tanımlandığını denetler.
MakeGenericMethod(Type[])	Belirtilen genel tür bağımsız değişkenlerini kullanarak geçerli genel yöntem tanımından yapılan genel bir yöntemi döndürür.
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
SetCustomAttribute(ConstructorInfo, Byte[])	Belirtilen özel öznitelik blobu kullanarak özel bir öznitelik ayarlar.
SetCustomAttribute(CustomAttributeBuilder)	Özel öznitelik oluşturucu kullanarak özel bir öznitelik ayarlar.
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	Türetilmiş bir sınıfta geçersiz kılındığında, bu derlemede özel bir öznitelik ayarlar.
SetImplementationFlags(MethodImplAttributes)	Bu yöntem için uygulama bayraklarını ayarlar.
SetImplementationFlagsCore(MethodImplAttributes)	Türetilmiş bir sınıfta geçersiz kılındığında, bu yöntem için uygulama bayraklarını ayarlar.
SetParameters(Type[])	Bir yöntem için parametre sayısını ve türlerini ayarlar.
SetReturnType(Type)	yönteminin dönüş türünü ayarlar.
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	Dönüş türü, parametre türleri ve dönüş türü ile parametre türlerinin gerekli ve isteğe bağlı özel değiştiricileri de dahil olmak üzere yöntem imzasını ayarlar.
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	Türetilmiş bir sınıfta geçersiz kılındığında, dönüş türü, parametre türleri ve dönüş türü ile parametre türlerinin gerekli ve isteğe bağlı özel değiştiricileri de dahil olmak üzere yöntem imzasını ayarlar.
ToString()	Bu MethodBuilder örneği dize olarak döndürür.

Uzantı Metotları

GetCustomAttribute(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute(MemberInfo, Type, Boolean)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
GetCustomAttribute<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute<T>(MemberInfo, Boolean)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
GetCustomAttributes(MemberInfo)	Belirtilen üyeye uygulanan özel öznitelikler koleksiyonunu alır.
GetCustomAttributes(MemberInfo, Boolean)	Belirtilen üyeye uygulanan özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes(MemberInfo, Type)	Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
GetCustomAttributes<T>(MemberInfo)	Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
IsDefined(MemberInfo, Type)	Belirtilen türde özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını gösterir.
IsDefined(MemberInfo, Type, Boolean)	Belirtilen türlerdeki özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını ve isteğe bağlı olarak, üstlerine uygulanıp uygulanmadığını gösterir.
GetMetadataToken(MemberInfo)	Varsa, verilen üye için bir meta veri belirteci alır.
HasMetadataToken(MemberInfo)	Belirtilen üye için bir meta veri belirtecinin kullanılabilir olup olmadığını gösteren bir değer döndürür.
GetBaseDefinition(MethodInfo)	Dinamik sınıftaki bir yöntemi (veya oluşturucuyu) tanımlar ve temsil eder.
GetRuntimeBaseDefinition(MethodInfo)	Yöntemin ilk bildirildiği doğrudan veya dolaylı temel sınıfta belirtilen yöntemi temsil eden bir nesnesi alır.