Click here to Skip to main content
Click here to Skip to main content

Tagged as

Compiling C# Code at Runtime

, 25 Jan 2014 CPOL
Rate this:
Please Sign up or sign in to vote.
This tip shows how to compile and use C# code during runtime and its impact on speed.


Sometimes, it is very useful to compile code at runtime. Personally, I use this feature mostly in these two cases:

  • Simple web tutorials – writing a small piece of code into TextBox control and its execution instead of the necessity to own or to run some IDE.
  • User-defined functions – I have written an application for symbolic regression with simple configuration file where user can choose some of my predefined functions (sin, cos, etc.). The user can also simply write his own mathematical expression with basic knowledge of C# language.

If you want to use this feature, you don’t have to install any third-party libraries. All functionality is provided by the .NET Framework in Microsoft.CSharp and System.CodeDom.Compiler namespaces.

Hello World Program

For compiling code at runtime, you need to follow these few steps:

  1. Write your code – most important part. Here you can write classes and methods into the string variable. We will add only Main method:
    string code = @"
        using System;
        namespace First
            public class Program
                public static void Main()
                " +
                    "Console.WriteLine(\"Hello, world!\");"
                    + @"
  2. Create the provider and parameters of the compiler:
    CSharpCodeProvider provider = new CSharpCodeProvider();
    CompilerParameters parameters = new CompilerParameters();
  3. Define parameters of the compiler (optional) – at this point, we can add a reference to external libraries. We can also define whether our compiled code will be generated only in the memory or into the DLL or EXE file:
    // Reference to System.Drawing library
    // True - memory generation, false - external file generation
    parameters.GenerateInMemory = true;
    // True - exe file generation, false - dll file generation
    parameters.GenerateExecutable = true;
  4. Compile assembly:
    CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
  5. Check errors:
    if (results.Errors.HasErrors)
        StringBuilder sb = new StringBuilder();
        foreach (CompilerError error in results.Errors)
            sb.AppendLine(String.Format("Error ({0}): {1}", error.ErrorNumber, error.ErrorText));
        throw new InvalidOperationException(sb.ToString());
  6. Get assembly, type and the Main method:
    Assembly assembly = results.CompiledAssembly;
    Type program = assembly.GetType("First.Program");
    MethodInfo main = program.GetMethod("Main");
  7. Run it:
    main.Invoke(null, null);

And that’s it. We have run our first runtime-compiled program!

User-defined Functions

As I mentioned in the Introduction, I use this feature for runtime defining mathematical expressions. Let’s look at creating simple functions with two parameters.

This is very similar to the previous example (it’s assumed that parameters of the function are named x and y). In this code, we simply replace part of the string with our desired function and compile it:

public static MethodInfo CreateFunction(string function)
    string code = @"
        using System;
        namespace UserFunctions
            public class BinaryFunction
                public static double Function(double x, double y)
                    return func_xy;

    string finalCode = code.Replace("func_xy", function);

    CSharpCodeProvider provider = new CSharpCodeProvider();
    CompilerResults results = provider.CompileAssemblyFromSource(new CompilerParameters(), finalCode);

    Type binaryFunction = results.CompiledAssembly.GetType("UserFunctions.BinaryFunction");
    return binaryFunction.GetMethod("Function");

At this point, we have written code for compiling user-defined functions so we use it by creating some function and invoking it:

MethodInfo function = CreateFunction("x + 2 * y");
object result = function.Invoke(null, new object[] { 2, 3 });

In this case, the result is equal to 8 so our compiler works fine but we have got result of the Object type and we must also provide parameters of the Object type. There is a much better way – creating a delegate:

var betterFunction = (Func<double, double, double>)Delegate.CreateDelegate
(typeof(Func<double, double, double>), function);

And there is a very simple way to invoke it:

double result = betterFunction(2, 3);

Speed Comparison

We have written a simple function compiler so now we have one function of 4 types:

  1. Original, at compile-time-defined function
  2. Runtime-compiled function invoked by Reflection
  3. Delegate created from the runtime-compiled function
  4. Lambda Expression Delegate ((x, y) => x + 2 * y)

Let’s write a simple program to compare their speed:

DateTime start;
DateTime stop;
double result;
int repetitions = 5000000;

start = DateTime.Now;
for (int i = 0; i < repetitions; i++)
    result = OriginalFunction(2, 3);
stop = DateTime.Now;
Console.WriteLine("Original - time: {0} ms", (stop - start).TotalMilliseconds);

start = DateTime.Now;
for (int i = 0; i < repetitions; i++)
    result = (double)function.Invoke(null, new object[] { 2, 3 });
stop = DateTime.Now;
Console.WriteLine("Reflection - time: {0} ms", (stop - start).TotalMilliseconds);

start = DateTime.Now;
for (int i = 0; i < repetitions; i++)
    result = betterFunction(2, 3);
stop = DateTime.Now;
Console.WriteLine("Delegate - time: {0} ms", (stop - start).TotalMilliseconds); 

start = DateTime.Now;
for (int i = 0; i < repetitions; i++)
    result = lambda(2, 3);
stop = DateTime.Now;
Console.WriteLine("Lambda - time: {0} ms", (stop - start).TotalMilliseconds);

After several tests, we will get the following results:

  1. Original – time: 92 ms
  2. Reflection – time: 3686 ms
  3. Delegate – time: 64 ms
  4. Lambda – time – 90 ms


Compiling C# code at runtime is very useful and easy task for various applications. I have shown how to create your own simple compiler. From speed results, it is obvious that speed of the runtime-compiled code is equal to the classical code (except the reflection-invoked case). 


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Lumír Kojecký
Czech Republic Czech Republic
I am a student of IT in Czech Republic. I am interested in C# language and .NET technology and currently I am focused on evolutionary algorithms and their application.
Follow on   Twitter   Google+

Comments and Discussions

GeneralMy vote of 5 PinmemberAntonio Nakić Alfirević19-Nov-14 0:22 
GeneralMy vote of 5 PinmemberBruno Sprecher18-Nov-14 2:00 
QuestionYour performance testing condition for four-methods is not fair. [modified] PinmemberSeong-Tae Jeong12-Feb-14 15:09 
SuggestionPerformance measurement PinmemberMember 1005484828-Jan-14 0:04 
Questionhow to save the result? PinmemberMBSMBS27-Jan-14 2:47 
AnswerRe: how to save the result? PinprofessionalLumír Kojecký27-Jan-14 3:06 
GeneralRe: how to save the result? PinmemberMBSMBS27-Jan-14 3:12 
GeneralRe: how to save the result? PinmemberLonelyCode31-Mar-14 4:18 
Questionmy vot of +5 Pinprofessionalabbaspirmoradi26-Jan-14 5:13 
GeneralMy vote of 5 PinmemberOleg Shilo25-Jan-14 15:34 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.141220.1 | Last Updated 25 Jan 2014
Article Copyright 2014 by Lumír Kojecký
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid