Dynamic Code Generation And Code Compilation

Introduction

This is a simple application for generating the code dynamically and compiling it dynamically. I have given two classes, GenerateClass, which generates a class on the fly, and RunClass, which compiles the generated class.

For dynamic code generation and code compilation, we have the CodeDom technology. Before going into the sample, let me give you a short introduction to CodeDom. Some applications need the generation and or compilation of source code at run time. The .NET Framework SDK provides a standard mechanism called the Code Document Object Model(CodeDOM) that enables the output of the source code in multiple programming languages at run time based on the single model that represents the code to render. The CodeDom namespace of .NET provides.

  1. A single model for rendering the source code. Therefore, we can extend the set of supported languages.
  2. A way to represent source code in a language-independent object model.
  3. Programs can be dynamically created, compiled, and executed at run time.

CodeDom architecture can conceptually represent most programming constructs. However, there are several limitations to the current CodeDom implementation. A few to mention are variable declaration lists, unsafe modifiers, aliasing the namespaces, nested namespaces, and others. To represent the constructs that are not provided by CodeDom, we can make use of the Snippet classes.

To talk about dynamic code generation and compilation, I have chosen the traditional example, Hello World. I tried to generate a code that would look like the following.

namespace Samples
{
    using System;
    public class HelloWorld
    {
        public HelloWorld()
        {
            WriteHelloWorld();
        }
        private void WriteHelloWorld()
        {
            Console.WriteLine("Hello World!!");
        }
        public static void Main()
        {
            HelloWorld hw = new HelloWorld();
        }
    }
}

How to generate the code?

To generate the code, we need to create IcodeGenerator and CsharpCodeProvider. Have a TextWriter to write the generated class.

// Output file name
string fileName = "HelloWorld.cs";
// Text writer to write the code
TextWriter tw = new StreamWriter(new FileStream(fileName, FileMode.Create));
// Code generator and code provider
ICodeGenerator codeGenerator = new CSharpCodeProvider().CreateGenerator();
CSharpCodeProvider cdp = new CSharpCodeProvider();
codeGenerator = cdp.CreateGenerator();
// Declare the namespace for the class and add the imports to the class
CodeNamespace Samples = new CodeNamespace("Samples");
Samples.Imports.Add(new CodeNamespaceImport("System"));

How to Create the class?

Creating a class in C# involves several steps, from defining the class structure to implementing its members. Below is a step-by-step guide on how to create a class in C#.

// Create a CodeTypeDeclaration named "HelloWorld"
CodeTypeDeclaration Class1 = new CodeTypeDeclaration("HelloWorld");
// Add the CodeTypeDeclaration to the Samples namespace
Samples.Types.Add(Class1);
// Set Class1 as a class
Class1.IsClass = true;

The constructor for the created class is.

// Create a CodeConstructor named cc
CodeConstructor cc = new CodeConstructor();
// Set the attributes of cc to public
cc.Attributes = MemberAttributes.Public;
// Add mi1 to the statements of the CodeConstructor
cc.Statements.Add(mi1);
// Add cc to the members of Class1
Class1.Members.Add(cc);

The method written HelloWorld can be given as.

// Create a CodeMemberMethod named Method1
CodeMemberMethod Method1 = new CodeMemberMethod();
Method1.Name = "writeHelloWorld";
Method1.ReturnType = new CodeTypeReference(typeof(void));
// Create a CodeMethodInvokeExpression to call System.Console.WriteLine
CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(
    new CodeTypeReferenceExpression("System.Console"),
    "WriteLine",
    new CodePrimitiveExpression("Hello World!!")
);
// Add the CodeMethodInvokeExpression to Method1's statements
Method1.Statements.Add(cs1);
// Add Method1 to the members of Class1
Class1.Members.Add(Method1);

How to create an executable?

 We should mention the entry point of the application. The method, Main, is given as.

// Create a CodeEntryPointMethod named Start
CodeEntryPointMethod Start = new CodeEntryPointMethod();
// Add a CodeSnippetStatement to Start
Start.Statements.Add(new CodeSnippetStatement("HelloWorld hw = new HelloWorld();"));
// Add Start to the members of Class1
Class1.Members.Add(Start);

Finally, generate the source code file.

// Generate code from the Samples namespace using the codeGenerator
codeGenerator.GenerateCodeFromNamespace(Samples, tw, null);

How to compile and run the code at run time? 

This, we need the ICodeCompiler.

// Create an instance of ICodeCompiler using CSharpCodeProvider
ICodeCompiler cc = new CSharpCodeProvider().CreateCompiler();

Set all the compiler parameters that you want. Note if you want to compile an assembly, set the GenerateExecutable to false.

// Create CompilerParameters
CompilerParameters cp = new CompilerParameters();
// Add a reference to "system.dll" to the referenced assemblies
cp.ReferencedAssemblies.Add("system.dll");
// Set GenerateExecutable to true to generate an executable
cp.GenerateExecutable = true;

After setting the parameters, compile the code and get the results. Check out for errors, if any.

// Compile the assembly from the specified file using CompilerParameters
CompilerResults cr = cc.CompileAssemblyFromFile(cp, fileName);
// Check if there are any compilation errors
if (cr.Errors.HasErrors)
{
    StringBuilder error = new StringBuilder();
    error.Append("Error Compiling Expression: ");
    // Iterate through each CompilerError and append the error text to the StringBuilder
    foreach (CompilerError err in cr.Errors)
    {
        error.AppendFormat("{0}\n", err.ErrorText);
    }
    // Throw an exception with the compiled error messages
    throw new Exception("Error Compiling Expression: " + error.ToString());
}

The last step, get the assembly generated and create an instance to run.

// Get the compiled assembly from CompilerResults
Assembly a = cr.CompiledAssembly;
// Create an instance of the "Samples.HelloWorld" class from the assembly
_Compiled = a.CreateInstance("Samples.HelloWorld");


Similar Articles