Export (0) Print
Expand All

TypeBuilder.CreateType Method

Creates a Type object for the class. After defining fields and methods on the class, CreateType is called in order to load its Type object.

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

public Type CreateType ()
public Type CreateType ()
public function CreateType () : Type
Not applicable.

Return Value

Returns the new Type object for this class.

Exception typeCondition

InvalidOperationException

The enclosing type has not been created.

-or-

This type is non-abstract and contains an abstract method.

-or-

This type is not an abstract class or an interface and has a method without a method body.

NotSupportedException

The type contains invalid Microsoft intermediate language (MSIL) code.

-or-

The branch target is specified using a 1-byte offset, but the target is at a distance greater than 127 bytes from the branch.

TypeLoadException

The type cannot be loaded. For example, it contains a static method that has the calling convention HasThis.

If this type is a nested type, the CreateType method must be called on the enclosing type before it is called on the nested type.

If the current type derives from an incomplete type or implements incomplete interfaces, call the CreateType method on the parent type and the interface types before calling it on the current type.

If the enclosing type contains a field that is a value type defined as a nested type (for example, a field that is an enumeration defined as a nested type), calling the CreateType method on the enclosing type will generate a AppDomain.TypeResolve event. This is because the loader cannot determine the size of the enclosing type until the nested type has been completed. The caller should define a handler for the TypeResolve event to complete the definition of the nested type by calling CreateType on the TypeBuilder object that represents the nested type. The code example for this topic shows how to define such an event handler.

A type is created only once, no matter how many times the CreateType method is called. All calls return the same Type object.

The following code example shows how to define an event handler for the AppDomain.TypeResolve event, in order to call the CreateType method on a nested type during a CreateType call on the enclosing type.


using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;
using System.Text;
using System.Resources;
using System.Collections;
using System.IO;

internal class NestedEnum {    
    internal static TypeBuilder enumType = null;
    internal static Type tNested = null;   
    internal static Type tNesting = null;

    public static void Main(String[] args) {
	AssemblyName asmName = new AssemblyName();
	asmName.Name = "NestedEnum";
	AssemblyBuilder asmBuild = Thread.GetDomain().DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
	ModuleBuilder modBuild = asmBuild.DefineDynamicModule("ModuleOne", "NestedEnum.dll");       

	// Hook up the event listening.
	TypeResolveHandler typeResolveHandler = new TypeResolveHandler(modBuild);
	// Add a listener for the type resolve events.
	AppDomain currentDomain = Thread.GetDomain();
	ResolveEventHandler resolveHandler = new ResolveEventHandler(typeResolveHandler.ResolveEvent);
	currentDomain.TypeResolve += resolveHandler;

	TypeBuilder tb = modBuild.DefineType("AType", TypeAttributes.Public);
	TypeBuilder eb = tb.DefineNestedType("AnEnum", TypeAttributes.NestedPublic | TypeAttributes.Sealed, typeof(Enum), null);
	eb.DefineField("value__", typeof(int), FieldAttributes.Private | FieldAttributes.SpecialName);
	FieldBuilder fb = eb.DefineField("Field1", eb, FieldAttributes.Public | FieldAttributes.Literal | FieldAttributes.Static);
	fb.SetConstant(1);

	enumType = eb;

	// Comment out this field.
	// When this field is defined, the loader cannot determine the size
	// of the type. Therefore, a TypeResolve event is generated when the
	// nested type is completed.
	tb.DefineField("Field2", eb, FieldAttributes.Public);        

	tNesting = tb.CreateType();
	if (tNesting == null)
	    Console.WriteLine("NestingType CreateType failed but didn't throw!");	

	try {
	    tNested = eb.CreateType();
	    if (tNested == null)
		Console.WriteLine("NestedType CreateType failed but didn't throw!");	
	}
	catch {
	    // This is needed because you might have already completed the type in the TypeResolve event.
	}

	if (tNested != null) {
	    Type x = tNested.DeclaringType;
	    if (x == null)
		Console.WriteLine("Declaring type was null.");
	    else 
		Console.WriteLine(x.Name);
	}

	asmBuild.Save( "NestedEnum.dll" );

	// Remove the listener for the type resolve events.
	currentDomain.TypeResolve -= resolveHandler;
    }
}

// Helper class called when a resolve type event is raised.
internal class TypeResolveHandler 
{
    private Module m_Module;

    public TypeResolveHandler(Module mod)
    {
	m_Module = mod;
    }

    public Assembly ResolveEvent(Object sender, ResolveEventArgs args)
    {
	Console.WriteLine(args.Name);
	// Use args.Name to look up the type name. In this case, you are getting AnEnum.
	try {
	    NestedEnum.tNested = NestedEnum.enumType.CreateType();
	}
	catch {
	    // This is needed to throw away InvalidOperationException.
	    // Loader might send the TypeResolve event more than once
	    // and the type might be complete already.
	}

	// Complete the type.		    
	return m_Module.Assembly;
    }
}
    

Windows 98, Windows Server 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

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

Community Additions

ADD
Show:
© 2014 Microsoft