MethodBuilder Class
Defines and represents a method (or constructor) on a dynamic class.
For a list of all members of this type, see MethodBuilder Members.
System.Object
System.Reflection.MemberInfo
System.Reflection.MethodBase
System.Reflection.MethodInfo
System.Reflection.Emit.MethodBuilder
[Visual Basic] NotInheritable Public Class MethodBuilder Inherits MethodInfo [C#] public sealed class MethodBuilder : MethodInfo [C++] public __gc __sealed class MethodBuilder : public MethodInfo [JScript] public class MethodBuilder extends MethodInfo
Thread Safety
Reflection Emit is thread-safe when using assemblies that were created with the AppDomain.DefineDynamicAssembly method with the Boolean parameter isSynchronized set to true.
Remarks
MethodBuilder is used to fully describe a method in Microsoft intermediate language (MSIL), including the name, attributes, signature, and method body. It is used in conjunction with the TypeBuilder class to create classes at runtime.
Example
[Visual Basic, C#, C++] An example using the MethodBuilder class to create a method within a dynamic type is provided below.
[Visual Basic] Imports System Imports System.Threading Imports System.Reflection Imports System.Reflection.Emit _ Class DemoMethodBuilder Public Shared Sub AddMethodDynamically(ByRef myTypeBld As TypeBuilder, _ mthdName As String, _ mthdParams() As Type, _ returnType As Type, _ 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 'AddMethodDynamically Public Shared Sub Main() Dim myDomain As AppDomain = Thread.GetDomain() Dim asmName As New AssemblyName() asmName.Name = "DynamicAssembly1" Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(asmName, _ AssemblyBuilderAccess.RunAndSave) Dim myModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("DynamicModule1", _ "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 or [M]ultiply these numbers? ") Dim myMthdAction As String = Console.ReadLine() 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 = "A" Then description = "adding" Else description = "multiplying" End If Console.WriteLine("---") Console.WriteLine("The result of {0} the inputted 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 'Main End Class 'DemoMethodBuilder [C#] using System; using System.Threading; using System.Reflection; using System.Reflection.Emit; class DemoMethodBuilder { public static void AddMethodDynamically (ref 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 = Thread.GetDomain(); AssemblyName asmName = new AssemblyName(); asmName.Name = "DynamicAssembly1"; AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly( asmName, AssemblyBuilderAccess.RunAndSave); ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule("DynamicModule1", "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 or [M]ultiply these numbers? "); string myMthdAction = Console.ReadLine(); 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(ref myTypeBld, myMthdName, myMthdParams, typeof(int), myMthdAction); Type myType = myTypeBld.CreateType(); Console.WriteLine("---"); Console.WriteLine("The result of {0} the inputted values is: {1}", ((myMthdAction == "A") ? "adding" : "multiplying"), 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()); } } [C++] #using <mscorlib.dll> using namespace System; using namespace System::Threading; using namespace System::Reflection; using namespace System::Reflection::Emit; void AddMethodDynamically (TypeBuilder* myTypeBld, String* mthdName, 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(S"A")) ILOut->Emit(OpCodes::Add); else if(mthdAction->Equals(S"M")) ILOut->Emit(OpCodes::Mul); else ILOut->Emit(OpCodes::Mul); } } ILOut->Emit(OpCodes::Ret); } int main() { AppDomain* myDomain = Thread::GetDomain(); AssemblyName* asmName = new AssemblyName(); asmName->Name = S"DynamicAssembly1"; AssemblyBuilder* myAsmBuilder = myDomain->DefineDynamicAssembly(asmName, AssemblyBuilderAccess::RunAndSave); ModuleBuilder* myModule = myAsmBuilder->DefineDynamicModule(S"DynamicModule1", S"MyDynamicAsm.dll"); TypeBuilder* myTypeBld = myModule->DefineType(S"MyDynamicType", TypeAttributes::Public); // Get info from the user to build the method dynamically. Console::WriteLine(S"Let's build a simple method dynamically!"); Console::WriteLine(S"Please enter a few numbers, separated by spaces."); String* inputNums = Console::ReadLine(); Console::Write(S"Do you want to [A]dd or [M]ultiply these numbers? "); String* myMthdAction = Console::ReadLine(); Console::Write(S"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(0); Type* myMthdParams[] = new Type*[inputNumsList->Length]; Object* inputValsList[] = new Object*[inputNumsList->Length]; System::Collections::IEnumerator* myEnum = inputNumsList->GetEnumerator(); while (myEnum->MoveNext()) { String* inputNum = __try_cast<String*>(myEnum->Current); inputValsList[index] = __box(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(S"---"); Console::WriteLine(S"The result of {0} the inputted values is: {1}", ((myMthdAction->Equals(S"A")) ? S"adding" : S"multiplying"), myType->InvokeMember(myMthdName,static_cast<BindingFlags>(BindingFlags::InvokeMethod | BindingFlags::Public | BindingFlags::Static), 0, 0, inputValsList)); Console::WriteLine(S"---"); // 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(S"MyDynamicAsm.dll"); MethodInfo* myMthdInfo = myType->GetMethod(myMthdName); Console::WriteLine(S"Your Dynamic Method: {0};", myMthdInfo); }
[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button
in the upper-left corner of the page.
Requirements
Namespace: System.Reflection.Emit
Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family
Assembly: Mscorlib (in Mscorlib.dll)