このオブジェクトの取得元である Type オブジェクトへの参照を示します。このプロパティは読み取り専用です。
Overrides Public ReadOnly Property ReflectedType As Type
[C#]
public override Type ReflectedType {get;}
[C++]
public: __property Type* get_ReflectedType();
[JScript]
public override function get ReflectedType() : Type;
プロパティ値
このインスタンスを取得するために使用した Type オブジェクトへの参照。
解説
FieldBuilder オブジェクトは、特定のクラスのフィールドを表します。 FieldBuilder オブジェクトを取得するには、フィールドをサポートするクラスを表す Type オブジェクトを照会します。このプロパティが、 Type オブジェクトへの参照を保持します。
ReflectedType の使用方法については、次のコード例を参照してください。
Imports System
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Public Class FieldBuilder_Sample
Private Shared Function CreateType(currentDomain As AppDomain) As Type
' Create an assembly.
Dim myAssemblyName As New AssemblyName()
myAssemblyName.Name = "DynamicAssembly"
Dim myAssembly As AssemblyBuilder = currentDomain.DefineDynamicAssembly(myAssemblyName, _
AssemblyBuilderAccess.Run)
' Create a dynamic module in Dynamic Assembly.
Dim myModuleBuilder As ModuleBuilder = myAssembly.DefineDynamicModule("MyModule")
' Define a public class named "MyClass" in the assembly.
Dim myTypeBuilder As TypeBuilder = myModuleBuilder.DefineType("MyClass", _
TypeAttributes.Public)
' Define a private String field named "MyField" in the type.
Dim myFieldBuilder As FieldBuilder = myTypeBuilder.DefineField("MyField", _
GetType(String), FieldAttributes.Private Or FieldAttributes.Static)
' Create the constructor.
Dim constructorArgs As Type() ={GetType(String)}
Dim myConstructor As ConstructorBuilder = _
myTypeBuilder.DefineConstructor(MethodAttributes.Public, _
CallingConventions.Standard, constructorArgs)
Dim constructorIL As ILGenerator = myConstructor.GetILGenerator()
constructorIL.Emit(OpCodes.Ldarg_0)
Dim superConstructor As ConstructorInfo = GetType(Object).GetConstructor(New Type() { })
constructorIL.Emit(OpCodes.Call, superConstructor)
constructorIL.Emit(OpCodes.Ldarg_0)
constructorIL.Emit(OpCodes.Ldarg_1)
constructorIL.Emit(OpCodes.Stfld, myFieldBuilder)
constructorIL.Emit(OpCodes.Ret)
' Create the MyMethod method.
Dim myMethodBuilder As MethodBuilder =myTypeBuilder.DefineMethod("MyMethod", _
MethodAttributes.Public, GetType(String), Nothing)
Dim methodIL As ILGenerator = myMethodBuilder.GetILGenerator()
methodIL.Emit(OpCodes.Ldarg_0)
methodIL.Emit(OpCodes.Ldfld, myFieldBuilder)
methodIL.Emit(OpCodes.Ret)
If myFieldBuilder.Attributes.Equals(FieldAttributes.Static) Then
Console.WriteLine("Field attribute defined as Static")
Else
If myFieldBuilder.Attributes.Equals(FieldAttributes.Static Or FieldAttributes.Private) Then
Console.WriteLine("Field attributes are Static and Private")
End If
End If
Console.WriteLine("ReflectedType of Field is :" + myFieldBuilder.ReflectedType.ToString())
Return myTypeBuilder.CreateType()
End Function 'CreateType
Public Shared Sub Main()
Try
Dim myType As Type = CreateType(Thread.GetDomain())
' Create an instance of the "HelloWorld" class.
Dim helloWorld As Object = Activator.CreateInstance(myType, New Object() { "HelloWorld" })
' Invoke the "MyMethod" of the "MyClass".
Dim myObject As Object = myType.InvokeMember("MyMethod", _
BindingFlags.InvokeMethod, Nothing, helloWorld, Nothing)
Console.WriteLine("MyClass.MyMethod returned: " & Microsoft.VisualBasic.Chr(34) & myObject & Microsoft.VisualBasic.Chr(34))
Catch e as Exception
Console.WriteLine("Exception Caught "+e.Message)
End Try
End Sub 'Main
End Class 'FieldBuilder_Sample
[C#]
using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
public class FieldBuilder_Sample
{
private static Type CreateType(AppDomain currentDomain)
{
// Create an assembly.
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "DynamicAssembly";
AssemblyBuilder myAssembly =
currentDomain.DefineDynamicAssembly(myAssemblyName,AssemblyBuilderAccess.Run);
// Create a dynamic module in Dynamic Assembly.
ModuleBuilder myModuleBuilder=myAssembly.DefineDynamicModule("MyModule");
// Define a public class named "MyClass" in the assembly.
TypeBuilder myTypeBuilder= myModuleBuilder.DefineType("MyClass",TypeAttributes.Public);
// Define a private String field named "MyField" in the type.
FieldBuilder myFieldBuilder= myTypeBuilder.DefineField("MyField",
typeof(string),FieldAttributes.Private|FieldAttributes.Static);
// Create the constructor.
Type[] constructorArgs = { typeof(String) };
ConstructorBuilder myConstructor = myTypeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard, constructorArgs);
ILGenerator constructorIL = myConstructor.GetILGenerator();
constructorIL.Emit(OpCodes.Ldarg_0);
ConstructorInfo superConstructor = typeof(Object).GetConstructor(new Type[0]);
constructorIL.Emit(OpCodes.Call, superConstructor);
constructorIL.Emit(OpCodes.Ldarg_0);
constructorIL.Emit(OpCodes.Ldarg_1);
constructorIL.Emit(OpCodes.Stfld, myFieldBuilder);
constructorIL.Emit(OpCodes.Ret);
// Create the MyMethod method.
MethodBuilder myMethodBuilder= myTypeBuilder.DefineMethod("MyMethod",
MethodAttributes.Public,typeof(String),null);
ILGenerator methodIL = myMethodBuilder.GetILGenerator();
methodIL.Emit(OpCodes.Ldarg_0);
methodIL.Emit(OpCodes.Ldfld, myFieldBuilder);
methodIL.Emit(OpCodes.Ret);
if (myFieldBuilder.Attributes.Equals(FieldAttributes.Static))
{
Console.WriteLine("Field attribute defined as Static");
}
else if(myFieldBuilder.Attributes.Equals(FieldAttributes.Static|FieldAttributes.Private))
{
Console.WriteLine("Field attributes are Static and Private");
}
Console.WriteLine("ReflectedType of Field is :"+myFieldBuilder.ReflectedType);
return myTypeBuilder.CreateType();
}
public static void Main()
{
try
{
Type myType = CreateType(Thread.GetDomain());
// Create an instance of the "HelloWorld" class.
Object helloWorld = Activator.CreateInstance(myType, new Object[] { "HelloWorld" });
// Invoke the "MyMethod" of the "MyClass".
Object myObject = myType.InvokeMember("MyMethod",
BindingFlags.InvokeMethod, null, helloWorld, null);
Console.WriteLine("MyClass.MyMethod returned: \"" + myObject + "\"");
}
catch (Exception e)
{
Console.WriteLine("Exception Caught "+e.Message);
}
}
}
[C++]
#using <mscorlib.dll>
using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type* CreateType(AppDomain* currentDomain)
{
// Create an assembly.
AssemblyName* myAssemblyName = new AssemblyName();
myAssemblyName->Name = S"DynamicAssembly";
AssemblyBuilder* myAssembly =
currentDomain->DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess::Run);
// Create a dynamic module in Dynamic Assembly.
ModuleBuilder* myModuleBuilder=myAssembly->DefineDynamicModule(S"MyModule");
// Define a public class named S"MyClass" in the assembly.
TypeBuilder* myTypeBuilder= myModuleBuilder->DefineType(S"MyClass", TypeAttributes::Public);
// Define a private String field named S"MyField" in the type.
FieldBuilder* myFieldBuilder= myTypeBuilder->DefineField(S"MyField",
__typeof(String), static_cast<FieldAttributes>(FieldAttributes::Private|FieldAttributes::Static));
// Create the constructor.
Type* constructorArgs[] = { __typeof(String) };
ConstructorBuilder* myConstructor = myTypeBuilder->DefineConstructor(MethodAttributes::Public, CallingConventions::Standard, constructorArgs);
ILGenerator* constructorIL = myConstructor->GetILGenerator();
constructorIL->Emit(OpCodes::Ldarg_0);
ConstructorInfo* superConstructor = __typeof(Object)->GetConstructor(new Type*[0]);
constructorIL->Emit(OpCodes::Call, superConstructor);
constructorIL->Emit(OpCodes::Ldarg_0);
constructorIL->Emit(OpCodes::Ldarg_1);
constructorIL->Emit(OpCodes::Stfld, myFieldBuilder);
constructorIL->Emit(OpCodes::Ret);
// Create the MyMethod method.
MethodBuilder* myMethodBuilder= myTypeBuilder->DefineMethod(S"MyMethod",
MethodAttributes::Public, __typeof(String), 0);
ILGenerator* methodIL = myMethodBuilder->GetILGenerator();
methodIL->Emit(OpCodes::Ldarg_0);
methodIL->Emit(OpCodes::Ldfld, myFieldBuilder);
methodIL->Emit(OpCodes::Ret);
if (__box(myFieldBuilder->Attributes)->Equals(__box(FieldAttributes::Static))) {
Console::WriteLine(S"Field attribute defined as Static");
} else if (__box(myFieldBuilder->Attributes)->Equals(__box(FieldAttributes::Static|FieldAttributes::Private))) {
Console::WriteLine(S"Field attributes are Static and Private");
}
Console::WriteLine(S"ReflectedType of Field is : {0}", myFieldBuilder->ReflectedType);
return myTypeBuilder->CreateType();
}
int main()
{
try {
Type* myType = CreateType(Thread::GetDomain());
// Create an instance of the S"HelloWorld" class.
Object* type[] = { S"HelloWorld" };
Object* helloWorld = Activator::CreateInstance(myType, type);
// Invoke the S"MyMethod" of the S"MyClass".
Object* myObject = myType->InvokeMember(S"MyMethod",
BindingFlags::InvokeMethod, 0, helloWorld, 0);
Console::WriteLine(S"MyClass::MyMethod returned: \"{0}\"", myObject);
} catch (Exception* e) {
Console::WriteLine(S"Exception Caught {0}", e->Message);
}
}
必要条件
プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ
参照
FieldBuilder クラス | FieldBuilder メンバ | System.Reflection.Emit 名前空間