TypeBuilder::DefineUninitializedData Method (String^, Int32, FieldAttributes)

 

Defines an uninitialized data field in the .sdata section of the portable executable (PE) file.

Namespace:   System.Reflection.Emit
Assembly:  mscorlib (in mscorlib.dll)

public:
FieldBuilder^ DefineUninitializedData(
	String^ name,
	int size,
	FieldAttributes attributes
)

Parameters

name
Type: System::String^

The name used to refer to the data. name cannot contain embedded nulls.

size
Type: System::Int32

The size of the data field.

attributes
Type: System.Reflection::FieldAttributes

The attributes for the field.

Return Value

Type: System.Reflection.Emit::FieldBuilder^

A field to reference the data.

Exception Condition
ArgumentException

Length of name is zero.

-or-

size is less than or equal to zero, or greater than or equal to 0x003f0000.

ArgumentNullException

name is null.

InvalidOperationException

The type was previously created using CreateType.

The field that you create with this method will be static, even if you do not include FieldAttributes.Static in the attributes parameter.

The following code sample demonstrates the use of DefineUninitializedData to create an uninitialized data field in a dynamic type:

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Runtime::InteropServices;
using namespace System::Security::Permissions;

public ref class Example
{
public:
   [SecurityPermission(SecurityAction::Demand, Flags=SecurityPermissionFlag::UnmanagedCode)]
   static void Main()
   {
      Type^ myHelloWorldType = CreateCallee( Thread::GetDomain() );
      Object^ myHelloWorldInstance = Activator::CreateInstance( myHelloWorldType );
      FieldInfo^ myGreetingFieldInfo = myHelloWorldType->GetField( "MyGreeting" );
      Object^ oval = Activator::CreateInstance( myGreetingFieldInfo->FieldType );
      IntPtr myIntPtr = Marshal::AllocHGlobal( 4 );
      Random^ rand = gcnew Random;
      int iTempSeed = rand->Next();
      array<Byte>^bINITBYTE = GetRandBytes( iTempSeed, 4 );
      IntPtr intptrTemp = myIntPtr;
      for ( int j = 0; j < 4; j++ )
      {
         Marshal::WriteByte( myIntPtr, bINITBYTE[ j ] );
         myIntPtr = (IntPtr)((int)myIntPtr + 1);

      }
      myIntPtr = intptrTemp;
      Object^ oValNew = Marshal::PtrToStructure( myIntPtr, myGreetingFieldInfo->FieldType );
      Marshal::FreeHGlobal( myIntPtr );
      myIntPtr = Marshal::AllocHGlobal( 4 );
      Object^ myObj = myGreetingFieldInfo->GetValue( myHelloWorldInstance );
      Marshal::StructureToPtr( myObj, myIntPtr, true );
      intptrTemp = myIntPtr;
      Console::WriteLine( "The value of 'MyGreeting' field : " );
      for ( int j = 0; j < 4; j++ )
      {
         Marshal::WriteByte( myIntPtr, bINITBYTE[ j ] );
         Console::WriteLine( bINITBYTE[ j ] );
         myIntPtr = (IntPtr)((int)myIntPtr + 1);

      }
   }


private:
   static array<Byte>^ GetRandBytes( int iRandSeed, int iSize )
   {
      array<Byte>^barr = gcnew array<Byte>(iSize);
      Random^ randTemp = gcnew Random( iRandSeed );
      randTemp->NextBytes( barr );
      return barr;
   }


   // Create the callee transient dynamic assembly.
   static Type^ CreateCallee( AppDomain^ myDomain )
   {

      // Create a simple name for the callee assembly.
      AssemblyName^ myAssemblyName = gcnew AssemblyName;
      myAssemblyName->Name = "EmittedClass";

      // Create the callee dynamic assembly.
      AssemblyBuilder^ myAssembly = myDomain->DefineDynamicAssembly( myAssemblyName, AssemblyBuilderAccess::Run );

      // Create a dynamic module in the callee assembly.
      ModuleBuilder^ myModule = myAssembly->DefineDynamicModule( "EmittedModule" );

      // Define a public class named "MyHelloWorld"
      TypeBuilder^ myHelloWorldType = myModule->DefineType( "MyHelloWorld", TypeAttributes::Public );

      // Define a 'MyGreeting' field and initialize it.
      FieldBuilder^ myFieldBuilder = myHelloWorldType->DefineUninitializedData( "MyGreeting", 4, FieldAttributes::Public );

      // Create the 'MyHelloWorld' class.
      return (myHelloWorldType->CreateType());
   }

};

int main()
{
   Example::Main();
}

.NET Framework
Available since 1.1
Silverlight
Available since 2.0
Return to top
Show: