FieldBuilder.ReflectedType 属性

定义

命名空间:

System.Reflection.Emit

程序集:

System.Reflection.Emit.dll

指示对从中获取此对象的 Type 对象的引用。 此属性为只读。

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

public override Type? ReflectedType { get; }

member this.ReflectedType : Type

Public Overrides ReadOnly Property ReflectedType As Type

属性值

Type

对从中获取该实例的 Type 对象的引用。

注解

对象 FieldBuilder 表示特定类的字段。 为了获取 FieldBuilder 对象， Type 将查询表示支持字段的类的 对象。 此属性保存对该 Type 对象的引用。

下面的代码示例演示如何使用 ReflectedType。

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

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

   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 + "\"");
   }
}

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
End Class