FieldBuilder-Klasse
Definiert ein Feld und stellt dieses dar. Diese Klasse kann nicht vererbt werden.
Namespace: System.Reflection.Emit
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
<ClassInterfaceAttribute(ClassInterfaceType.None)> _
<ComVisibleAttribute(True)> _
Public NotInheritable Class FieldBuilder
Inherits FieldInfo
Implements _FieldBuilder
'Usage
Dim instance As FieldBuilder
[ClassInterfaceAttribute(ClassInterfaceType.None)]
[ComVisibleAttribute(true)]
public sealed class FieldBuilder : FieldInfo, _FieldBuilder
[ClassInterfaceAttribute(ClassInterfaceType::None)]
[ComVisibleAttribute(true)]
public ref class FieldBuilder sealed : public FieldInfo, _FieldBuilder
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */
/** @attribute ComVisibleAttribute(true) */
public final class FieldBuilder extends FieldInfo implements _FieldBuilder
ClassInterfaceAttribute(ClassInterfaceType.None)
ComVisibleAttribute(true)
public final class FieldBuilder extends FieldInfo implements _FieldBuilder
Hinweise
Hinweis
Das auf diese Klasse angewendete HostProtectionAttribute-Attribut besitzt den Resources-Eigenschaftenwert MayLeakOnAbort. Das HostProtectionAttribute hat keine Auswirkungen auf Desktopanwendungen (die normalerweise durch Doppelklicken auf ein Symbol, Eingeben eines Befehls oder eines URL in einem Browser gestartet werden). Weitere Informationen finden Sie unter der HostProtectionAttribute-Klasse oder unter SQL Server-Programmierung und Hostschutzattribute.
Ruft eine Instanz von FieldBuilder durch Aufrufen von DefineField, DefineInitializedData oder DefineUninitializedData ab.
Hinweis
Die SetValue-Methode wird derzeit nicht unterstützt. Rufen Sie zum Umgehen des Problems FieldInfo ab, indem Sie eine Reflektion für den abgeschlossenen Typ durchführen, und rufen Sie SetValue auf, um den Wert des Felds festzulegen.
Beispiel
Das folgende Codebeispiel veranschaulicht die Verwendung von FieldBuilder.
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 constructor As ConstructorBuilder = _
myTypeBuilder.DefineConstructor(MethodAttributes.Public, _
CallingConventions.Standard, constructorArgs)
Dim constructorIL As ILGenerator = constructor.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)
Console.WriteLine("Name :" + myFieldBuilder.Name)
Console.WriteLine("DeclaringType :" + myFieldBuilder.DeclaringType.ToString())
Console.WriteLine("Type :" + myFieldBuilder.FieldType.ToString())
Console.WriteLine("Token :" + myFieldBuilder.GetToken().Token.ToString())
Return myTypeBuilder.CreateType()
End Function 'CreateType
<PermissionSetAttribute(SecurityAction.Demand, Name:="FullTrust")> _
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" method of the "MyClass" class.
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
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 constructor = myTypeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard, constructorArgs);
ILGenerator constructorIL = constructor.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);
Console.WriteLine("Name :"+myFieldBuilder.Name);
Console.WriteLine("DeclaringType :"+myFieldBuilder.DeclaringType);
Console.WriteLine("Type :"+myFieldBuilder.FieldType);
Console.WriteLine("Token :"+myFieldBuilder.GetToken().Token);
return myTypeBuilder.CreateType();
}
[PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
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" method of the "MyClass" class.
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);
}
}
}
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^ constructor = myTypeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, constructorArgs );
ILGenerator^ constructorIL = constructor->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 );
Console::WriteLine( "Name : {0}", myFieldBuilder->Name );
Console::WriteLine( "DeclaringType : {0}", myFieldBuilder->DeclaringType );
Console::WriteLine( "Type : {0}", myFieldBuilder->FieldType );
Console::WriteLine( "Token : {0}", myFieldBuilder->GetToken().Token );
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" method of the S"MyClass" class.
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 );
}
}
Vererbungshierarchie
System.Object
System.Reflection.MemberInfo
System.Reflection.FieldInfo
System.Reflection.Emit.FieldBuilder
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Plattformen
Windows 98, Windows 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
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0