FieldBuilder.ReflectedType プロパティとは何？わかりやすく解説 Weblio辞書

すべての辞書から再検索する

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

FieldBuilder.ReflectedType プロパティ

このオブジェクトの取得元である Type オブジェクトへの参照を示します。このプロパティは読み取り専用です。

名前空間: System.Reflection.Emit
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

Public Overrides ReadOnly
 Property ReflectedType As Type

Visual Basic (使用法)

Dim instance As FieldBuilder
Dim value As Type

value = instance.ReflectedType

public override Type ReflectedType { get; }

C++

public:
virtual property Type^ ReflectedType {
    Type^ get () override;
}

/** @property */
public Type get_ReflectedType ()

JScript

public override function get
 ReflectedType () : Type

プロパティ値
このインスタンスを取得するために使用した Type オブジェクトへの参照。

解説

FieldBuilder オブジェクトは、特定のクラスのフィールドを表します。FieldBuilder オブジェクトを取得するには、フィールドをサポートするクラスを表す Type オブジェクトを照会します。このプロパティが、Type オブジェクトへの参照を保持します。

ReflectedType の使用方法については、次のコード例を参照してください。

Visual Basic

Imports System
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Security.Permissions

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

   <PermissionSetAttribute(SecurityAction.Demand, Name:="FullTrust")>
 _
   Public Shared Sub Main()
      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: """
 & myObject & """")
   End Sub 'Main
End Class 'FieldBuilder_Sample

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Security.Permissions;

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

   [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
   public static void Main()
   {
      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
 + "\"");
   }
}

C++

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 = gcnew 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 S"MyClass" in the assembly.
   TypeBuilder^ myTypeBuilder = myModuleBuilder->DefineType( "MyClass",
 TypeAttributes::Public );

   // Define a private String field named S"MyField" in the
 type.
   FieldBuilder^ myFieldBuilder = myTypeBuilder->DefineField( "MyField",
 String::typeid, static_cast<FieldAttributes>(FieldAttributes::Private | FieldAttributes::Static)
 );

   // Create the constructor.
   array<Type^>^constructorArgs = {String::typeid};
   ConstructorBuilder^ myConstructor = myTypeBuilder->DefineConstructor( MethodAttributes::Public,
 CallingConventions::Standard, constructorArgs );
   ILGenerator^ constructorIL = myConstructor->GetILGenerator();
   constructorIL->Emit( OpCodes::Ldarg_0 );
   ConstructorInfo^ superConstructor = Object::typeid->GetConstructor( gcnew array<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, String::typeid, nullptr );
   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 : {0}", myFieldBuilder->ReflectedType
 );
   return myTypeBuilder->CreateType();
}

int main()
{
   try
   {
      Type^ myType = CreateType( Thread::GetDomain() );

      // Create an instance of the S"HelloWorld" class.
      array<Object^>^type = {"HelloWorld"};
      Object^ helloWorld = Activator::CreateInstance( myType, type );

      // Invoke the S"MyMethod"  of the S"MyClass".
      Object^ myObject = myType->InvokeMember( "MyMethod", BindingFlags::InvokeMethod,
 nullptr, helloWorld, nullptr );
      Console::WriteLine( "MyClass::MyMethod returned: \"{0}\"",
 myObject );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception Caught {0}", e->Message );
   }
}

プラットフォーム

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0

参照

関連項目
FieldBuilder クラス
FieldBuilder メンバ
System.Reflection.Emit 名前空間

このページでは「.NET Framework クラスライブラリリファレンス」からFieldBuilder.ReflectedType プロパティを検索した結果を表示しています。
Weblioに収録されているすべての辞書からFieldBuilder.ReflectedType プロパティを検索する場合は、下記のリンクをクリックしてください。

全ての辞書からFieldBuilder.ReflectedType プロパティを検索

>> 「FieldBuilder.ReflectedType プロパティ」を含む用語の索引
FieldBuilder.ReflectedType プロパティのページへのリンク


	© 2025 Microsoft.All rights reserved.

FieldBuilder.ReflectedType プロパティとは？ わかりやすく解説

FieldBuilder.ReflectedType プロパティ

急上昇のことば

FieldBuilder.ReflectedType プロパティとは？わかりやすく解説