Dynamically Activating Code

the underlying protocol. Furthermore, with late-bound implementation, new protocols with the proper interface, packaged in their own DLLs, could be added to the framework at any time, without recompilation of the code. The late-bound capabilities of reflection could enable this scenario by assisting in the runtime determination of what transport protocol would be used for SOAP packages.

Examples in this chapter do not attempt to be this ambitious. However, Listing 28.4 shows how to perform a late-bound operation by dynamically activating the code in a specified assembly during runtime.

LISTING 28.4 Dynamically Activating Code: Reflecting.cs

using System;

using System.Reflection;

///<summary>

///Dynamically Activating Code.

///</summary>

class Reflecting

{

static void Main(string[] args)

{

Reflecting reflect = new Reflecting();

Assembly myAssembly

= Assembly.LoadFrom(“Reflecting.exe”);

reflect.DynamicallyInvokeMembers(myAssembly);

}

void DynamicallyInvokeMembers(Assembly myAssembly)

{

Type classType = myAssembly.GetType(“Reflected”);

PropertyInfo myProperty

= classType.GetProperty(“MyProperty”);

MethodInfo propGet = myProperty.GetGetMethod();

object reflectedObject

= Activator.CreateInstance(classType);

propGet.Invoke(reflectedObject, null);

MethodInfo myMethod

= classType.GetMethod(“MyInstanceMethod”);

myMethod.Invoke(reflectedObject, null);

}

}

28

EFLECTIONR

runtime. These assemblies may be dynamically invoked or saved to file where they may be reloaded and invoked or used by other programs.

Dynamic assembly creation can be useful for back-ends to compilers or scripting engines on tools such as Web browsers. Using the Reflection.Emit API, any tool can be extended to dynamically support .NET or any other Common Language Infrastructure (CLI) compliant system. Listing 28.6 shows how to both generate a dynamic assembly and save it as a console program.

LISTING 28.6 Dynamic Assembly Generation

using System;

using System.Reflection; using System.Reflection.Emit;

///<summary>

///Reflection Emit.

///</summary>

class Emit

{

static void Main(string[] args)

{

AppDomain myAppDomain = AppDomain.CurrentDomain;

AssemblyName myAssemblyName = new AssemblyName(); myAssemblyName.Name = “DynamicAssembly”;

AssemblyBuilder myAssemblyBuilder = myAppDomain.DefineDynamicAssembly( myAssemblyName, AssemblyBuilderAccess.RunAndSave);

ModuleBuilder myModuleBuilder = myAssemblyBuilder.DefineDynamicModule( “DynamicModule”,

“emitter.netmodule”);

TypeBuilder myTypeBuilder = myModuleBuilder.DefineType( “EmitTestClass”);

MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod( “Main”,

MethodAttributes.Public|MethodAttributes.Static,

null,

null);

28

EFLECTIONR

The AssemblyBuilder object is created by calling the DefineDynamicAssembly() method of the AppDomain object. The parameters passed to DefineDynamicAssembly() are an AssemblyName object and an AssemblyBuilderAccess enum. The AssemblyBuilderAccess enum has three members: Run, RunAndSave, and Save. Run means the assembly can only be invoked in memory; Save means that the assembly can only be persisted (saved) to file; and RunAndSave means both Run and Save.

With an AssemblyBuilder object, a ModuleBuilder object is created. The parameters of the DefineDynamicModule() method are a string with name for the module and another string with the filename the module will be saved as. The example shows that the module filename will be “emitter.netmodule”.

Tip

The DefineDynamicModule() method has four overloads: two are for run-only modules and the other two are for run and persist modules. To guarantee that a module is included during persistence of an assembly, ensure one of the overloads with the filename parameter of the DefineDynamicAssembly() method is used.

TypeBuilder objects are created with the DefineType() method of the ModuleBuilder object. The DefineType() method takes a single string parameter with the name of the

Type.

The final builder object in Listing 28.6 is the MethodBuilder, which is created using the

DefineMethod() method of the TypeBuilder object. DefineMethod() has four parameters: name, method attributes, return type, and parameter types.

The name parameter is a string with the name of the method. In this case, it’s the Main() method. Since a Main() method must be defined as public and static, the second parameter uses the Public and Static members of the MethodAttributes enum. The return type is null, which defaults to void, and the parameter types is also null which means that this method does not accept arguments. When a method accepts arguments, the fourth parameter would be an array with the type definitions of each method parameter.

Next, the code is generated. To accomplish this, invoke the MethodBuilder object’s GetILGenerator() method. This results in an ILGenerator class that is used to create code.

This is a very simple method that writes a line of text to the console and returns. The EmitWriteLine() and Emit() methods perform this task.

28

EFLECTIONR