Export (0) Print
Expand All

MethodBuilder Class

Defines and represents a method (or constructor) on a dynamic class.

Namespace: System.Reflection.Emit
Assembly: mscorlib (in mscorlib.dll)

[ComVisibleAttribute(true)] 
[ClassInterfaceAttribute(ClassInterfaceType.None)] 
public sealed class MethodBuilder : MethodInfo, _MethodBuilder
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */ 
public final class MethodBuilder extends MethodInfo implements _MethodBuilder
ComVisibleAttribute(true) 
ClassInterfaceAttribute(ClassInterfaceType.None) 
public final class MethodBuilder extends MethodInfo implements _MethodBuilder
Not applicable.

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.

An example using the MethodBuilder class to create a method within a dynamic type is provided below.


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()); 
	
	}

}


import System.*;
import System.Threading.*;
import System.Reflection.*;
import 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 (ubyte 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") == true) {
                    iLout.Emit(OpCodes.Add);
                }
                else if (mthdAction.Equals("M") == true) {
                    iLout.Emit(OpCodes.Mul);
                }
                else {
                    iLout.Emit(OpCodes.Add);
                }
            }
        }
        iLout.Emit(OpCodes.Ret);
    } //AddMethodDynamically
 
    public static void main(String[] args)
    {
        AppDomain myDomain = System.Threading.Thread.GetDomain();
        AssemblyName asmName = new AssemblyName();
        asmName.set_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(null);
        Type myMthdParams[] = new Type[inputNumsList.length];
        Object inputValsList[] = new Object[inputNumsList.length];
        for (int iCtr = 0; iCtr < inputNumsList.length; iCtr++) {
            String inputNum = inputNumsList[iCtr];
            inputValsList[index] = (Object)(Int32)Integer.parseInt(inputNum);
            myMthdParams.set_Item(index, int.class.ToType());
            index++;
        }

        // Now, call the method building method with the parameters,
        // passing the TypeBuilder by reference.
        AddMethodDynamically(myTypeBld, myMthdName, myMthdParams,
            int.class.ToType(), myMthdAction);
        Type myType = myTypeBld.CreateType();
        Console.WriteLine("---");
        Console.WriteLine("The result of {0} the inputted values is: {1}",
            (myMthdAction.equals("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 the method you provided 
        // during execution.
        myAsmBuilder.Save("MyDynamicAsm.dll");
        MethodInfo myMthdInfo = myType.GetMethod(myMthdName);
        Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString());
    } //main 
} //DemoMethodBuilder

System.Object
   System.Reflection.MemberInfo
     System.Reflection.MethodBase
       System.Reflection.MethodInfo
        System.Reflection.Emit.MethodBuilder

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 98, Windows Server 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

Community Additions

ADD
Show:
© 2015 Microsoft