This documentation is archived and is not being maintained.

TypeBuilder.DefineTypeInitializer Method

Defines the initializer for this type.

[Visual Basic]
Public Function DefineTypeInitializer() As ConstructorBuilder
[C#]
public ConstructorBuilder DefineTypeInitializer();
[C++]
public: ConstructorBuilder* DefineTypeInitializer();
[JScript]
public function DefineTypeInitializer() : ConstructorBuilder;

Return Value

Returns a type initializer.

Exceptions

Exception Type Condition
InvalidOperationException The containing type has been previously created using CreateType.

Remarks

The initializer created is always public.

Example

[Visual Basic, C#, C++] The following code sample demonstrates how to create an initialization constructor using DefineTypeInitializer.

[Visual Basic] 
Public Class MyApplication

   Public Shared Sub Main()
      ' Create the "HelloWorld" class
      Dim helloWorldClass As TypeBuilder = CreateCallee(Thread.GetDomain())
      Console.WriteLine("Full Name : " + helloWorldClass.FullName)
      Console.WriteLine("Constructors :")
      Dim info As ConstructorInfo() = helloWorldClass.GetConstructors(BindingFlags.Public Or _
                                                                     BindingFlags.Instance)
      Dim index As Integer
      For index = 0 To info.Length - 1
         Console.WriteLine(info(index).ToString())
      Next index
   End Sub 'Main

   ' Create the callee transient dynamic assembly.
   Private Shared Function CreateCallee(myDomain As AppDomain) As TypeBuilder
      Dim myAssemblyName As New AssemblyName()
      myAssemblyName.Name = "EmittedAssembly"

      ' Create the callee dynamic assembly.
      Dim myAssembly As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAssemblyName, _
                                                               AssemblyBuilderAccess.Run)
      ' Create a dynamic module named "CalleeModule" in the callee assembly.
      Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule("EmittedModule")

      ' Define a public class named "HelloWorld" in the assembly.
      Dim helloWorldClass As TypeBuilder = myModule.DefineType("HelloWorld", TypeAttributes.Public)
      ' Define a private String field named "Greeting" in the type.
      Dim greetingField As FieldBuilder = helloWorldClass.DefineField("Greeting", GetType(String), _
                                                                     FieldAttributes.Private)

      ' Create the constructor.
      Dim constructor As ConstructorBuilder = helloWorldClass.DefineTypeInitializer()

      ' Generate IL for the method. The constructor calls its base class
      ' constructor. The constructor stores its argument in the private field.
      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, greetingField)
      constructorIL.Emit(OpCodes.Ret)

      helloWorldClass.CreateType()
      Return helloWorldClass
   End Function 'CreateCallee
End Class 'MyApplication

[C#] 
public class MyApplication
{
   public static void Main()
   {
      // Create the "HelloWorld" class
      TypeBuilder helloWorldClass = CreateCallee(Thread.GetDomain());
      Console.WriteLine("Full Name : " + helloWorldClass.FullName);
      Console.WriteLine("Constructors :");
      ConstructorInfo[] info =
         helloWorldClass.GetConstructors(BindingFlags.Public|BindingFlags.Instance);
      for(int index=0; index < info.Length; index++)
         Console.WriteLine(info[index].ToString());
   }

   // Create the callee transient dynamic assembly.
   private static TypeBuilder CreateCallee(AppDomain myDomain)
   {
      AssemblyName myAssemblyName = new AssemblyName();
      myAssemblyName.Name = "EmittedAssembly";

      // Create the callee dynamic assembly.
      AssemblyBuilder myAssembly = myDomain.DefineDynamicAssembly(myAssemblyName,
         AssemblyBuilderAccess.Run);
      // Create a dynamic module named "CalleeModule" in the callee assembly.
      ModuleBuilder myModule = myAssembly.DefineDynamicModule("EmittedModule");

      // Define a public class named "HelloWorld" in the assembly.
      TypeBuilder helloWorldClass = myModule.DefineType("HelloWorld", TypeAttributes.Public);
      // Define a private String field named "Greeting" in the type.
      FieldBuilder greetingField = helloWorldClass.DefineField("Greeting", typeof(String),
         FieldAttributes.Private);

      // Create the constructor.
      ConstructorBuilder constructor = helloWorldClass.DefineTypeInitializer();

      // Generate IL for the method. The constructor calls its base class
      // constructor. The constructor stores its argument in the private field.
      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, greetingField);
      constructorIL.Emit(OpCodes.Ret);

      helloWorldClass.CreateType();
      return(helloWorldClass);
   }
}

[C++] 
// Create the callee transient dynamic assembly.
TypeBuilder* CreateCallee(AppDomain* myDomain)
{
    AssemblyName* myAssemblyName = new AssemblyName();
    myAssemblyName->Name = S"EmittedAssembly";

    // Create the callee dynamic assembly.
    AssemblyBuilder* myAssembly = myDomain->DefineDynamicAssembly(myAssemblyName,
        AssemblyBuilderAccess::Run);
    // Create a dynamic module named "CalleeModule" in the callee assembly.
    ModuleBuilder* myModule = myAssembly->DefineDynamicModule(S"EmittedModule");

    // Define a public class named "HelloWorld" in the assembly.
    TypeBuilder* helloWorldClass = myModule->DefineType(S"HelloWorld", TypeAttributes::Public);
    // Define a private String field named "Greeting" in the type.
    FieldBuilder* greetingField = helloWorldClass->DefineField(S"Greeting", __typeof(String),
        FieldAttributes::Private);

    // Create the constructor.
    ConstructorBuilder* constructor = helloWorldClass->DefineTypeInitializer();

    // Generate IL for the method. The constructor calls its base class
    // constructor. The constructor stores its argument in the private field.
    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, greetingField);
    constructorIL->Emit(OpCodes::Ret);

    helloWorldClass->CreateType();
    return(helloWorldClass);
}

int main()
{
    // Create the "HelloWorld" class
    TypeBuilder* helloWorldClass = CreateCallee(Thread::GetDomain());
    Console::WriteLine(S"Full Name : {0}", helloWorldClass->FullName);
    Console::WriteLine(S"Constructors :");
    ConstructorInfo* info[] =
        helloWorldClass->GetConstructors(static_cast<BindingFlags>(BindingFlags::Public|BindingFlags::Instance));
    for(int index=0; index < info->Length; index++)
        Console::WriteLine(info[index]);
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

See Also

TypeBuilder Class | TypeBuilder Members | System.Reflection.Emit Namespace

Show: