TypeBuilder.DefineUninitializedData(String, Int32, FieldAttributes) Méthode

Référence

Définition

Espace de noms:: System.Reflection.Emit

Assembly:: System.Reflection.Emit.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Paquet:: System.Reflection.Emit v4.7.0

Source:: TypeBuilder.cs

Source:: TypeBuilder.cs

Source:: TypeBuilder.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Définit un champ de données non initialisé dans la section .sdata du fichier exécutable portable (PE).

public:
 System::Reflection::Emit::FieldBuilder ^ DefineUninitializedData(System::String ^ name, int size, System::Reflection::FieldAttributes attributes);

public System.Reflection.Emit.FieldBuilder DefineUninitializedData (string name, int size, System.Reflection.FieldAttributes attributes);

member this.DefineUninitializedData : string * int * System.Reflection.FieldAttributes -> System.Reflection.Emit.FieldBuilder

Public Function DefineUninitializedData (name As String, size As Integer, attributes As FieldAttributes) As FieldBuilder

Paramètres

name: String

Nom utilisé pour faire référence aux données. name ne peut pas contenir des valeurs Null imbriquées.

size: Int32

Taille du champ de données.

attributes: FieldAttributes

Attributs du champ.

Retours

FieldBuilder

Champ pour référencer les données.

Exceptions

ArgumentException

La longueur de name est égale à zéro.

- ou -

size est inférieur ou égal à zéro, ou supérieur ou égal à 0x003f0000.

ArgumentNullException

name a la valeur null.

InvalidOperationException

Le type a déjà été créé en utilisant CreateType().

Exemples

L’exemple de code suivant illustre l’utilisation de pour créer un champ de DefineUninitializedData données non initialisé dans un type dynamique :

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

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

public sealed class Example
{
   public 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 = new Random();
      int iTempSeed = rand.Next();
      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 byte[] GetRandBytes( int iRandSeed, int iSize )
   {
      byte[] barr = new byte[iSize];
      Random randTemp = new Random( iRandSeed );
      randTemp.NextBytes( barr );
      return barr;
   }

   // Create the callee transient dynamic assembly.
   private static Type CreateCallee(AppDomain myDomain)
   {
      // Create a simple name for the callee assembly.
      AssemblyName myAssemblyName = new 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());
   }

   private Example() {}
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Runtime.InteropServices


Module Example

   Sub Main()
      Dim myHelloWorldType As Type = CreateCallee(Thread.GetDomain())
      Dim myHelloWorldInstance As Object = Activator.CreateInstance(myHelloWorldType)
      Dim myGreetingFieldInfo As FieldInfo = myHelloWorldType.GetField("MyGreeting")
      Dim oval As Object = Activator.CreateInstance(myGreetingFieldInfo.FieldType)
      Dim myIntPtr As IntPtr = Marshal.AllocHGlobal(4)
      Dim rand As New Random()
      Dim iTempSeed As Integer = rand.Next()
      Dim bINITBYTE As Byte() = GetRandBytes(iTempSeed, 4)
      Dim intptrTemp As IntPtr = myIntPtr
      Dim j As Integer
      For j = 0 To 3
         Marshal.WriteByte(myIntPtr, bINITBYTE(j))
         myIntPtr = intptr.op_Explicit(myIntPtr.ToInt32 + 1)
      Next j
      myIntPtr = intptrTemp
      Dim oValNew As [Object] = Marshal.PtrToStructure(myIntPtr, myGreetingFieldInfo.FieldType)
      Marshal.FreeHGlobal(myIntPtr)

      myIntPtr = Marshal.AllocHGlobal(4)
      Dim myObj As Object = myGreetingFieldInfo.GetValue(myHelloWorldInstance)
      Marshal.StructureToPtr(myObj, myIntPtr, True)
      intptrTemp = myIntPtr
      Console.WriteLine("The value of 'MyGreeting' field : ")

      For j = 0 To 3
         Marshal.WriteByte(myIntPtr, bINITBYTE(j))
         Console.WriteLine(bINITBYTE(j))
         myIntPtr = intptr.op_Explicit(myIntPtr.ToInt32 + 1)
      Next j
   End Sub


   Private Function GetRandBytes(ByVal iRandSeed As Integer, ByVal iSize As Integer) As Byte()
      Dim barr(iSize) As Byte
      Dim randTemp As New Random(iRandSeed)
      randTemp.NextBytes(barr)
      Return barr
   End Function 'GetRandBytes


   ' Create the callee transient dynamic assembly.
   Private Function CreateCallee(ByVal myDomain As AppDomain) As Type
      ' Create a simple name for the callee assembly.
      Dim myAssemblyName As New AssemblyName()
      myAssemblyName.Name = "EmittedClass"

      ' Create the callee dynamic assembly.
      Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAssemblyName, AssemblyBuilderAccess.Run)


      ' Create a dynamic module in the callee assembly.
      Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule("EmittedModule")

      ' Define a public class named "MyHelloWorld"
      Dim myHelloWorldType As TypeBuilder = myModule.DefineType("MyHelloWorld", TypeAttributes.Public)

      ' Define a 'MyGreeting' field and initialize it.
      Dim myFieldBuilder As FieldBuilder = myHelloWorldType.DefineUninitializedData("MyGreeting", 4, FieldAttributes.Public)

      ' Create the 'MyHelloWorld' class.
      Return myHelloWorldType.CreateType()
   End Function 'CreateCallee

End Module

Remarques

Le champ que vous créez avec cette méthode sera static, même si vous n’incluez FieldAttributes.Static pas dans le attributes paramètre .

S’applique à

Partager via