MethodBuilder クラス
動的クラスのメソッド (またはコンストラクタ) を定義および表現します。
この型のすべてのメンバの一覧については、MethodBuilder メンバ を参照してください。
System.Object
System.Reflection.MemberInfo
System.Reflection.MethodBase
System.Reflection.MethodInfo
System.Reflection.Emit.MethodBuilder
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
スレッドセーフ
Reflection Emit は、Boolean パラメータ isSynchronized を true に設定して呼び出した AppDomain.DefineDynamicAssembly メソッドで作成されたアセンブリを使用する場合は、スレッド セーフです。
解説
MethodBuilder を使用して、MSIL (Microsoft Intermediate Language) のメソッドを完全に記述します。名前、属性、シグネチャ、メソッド本体が含まれます。 TypeBuilder クラスと組み合わせて使用され、実行時にクラスを作成します。
使用例
[Visual Basic, C#, C++] MethodBuilder クラスを使用して、動的な型の中にメソッドを作成する方法を次の例に示します。
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] JScript のサンプルはありません。Visual Basic、C#、および C++ のサンプルを表示するには、このページの左上隅にある言語のフィルタ ボタン .gif)
をクリックします。
必要条件
名前空間: System.Reflection.Emit
プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ
アセンブリ: Mscorlib (Mscorlib.dll 内)