C# offers the great possibility to compile your own assemblies at runtime. However, there is no possibility to unload such compilations, to unload dynamic generated assemblies at runtime. The only way to do this is to create such assemblies in your own Domain and to unload such Domains later on but the communication between Domains is slow like inter process communication. Additional, to load the C# compiler environment and the compilation itself is not very fast at runtime, not nice for documents with hundreds of small internal scripts.
There are already quite a few articles about dynamic code generation using .NET and how to ship around these problems, but nothing was good enough for my case. The idea was to write my own C# script compiler based on C# syntax and conventions and to use Dynamic Methods to generate IL for best performance.
I found out that this works well without any assembly generation. With such solution, it is possible to use all existing classes and value structures but it is not possible to define your own new classes. The reason for this is that a .NET class always needs an assembly and the related assembly information.
However, the script itself works like a unique class with member functions and variables.
Using the Demo
For demonstration purposes, I wrote a small and very limited test program, only three C# files:
Program.cs contains a very simple user interface and EditCtrl.cs a simple code editor control.
The file Script.cs contains the class
Script and this class is easy to use in other C# projects.
The demo looks like this and can be used to check and debug functionality and speed, the directory Demos contains some demo scripts for this.
Using the Code
To use the code in other C# projects, it is only necessary to import the class
Script from Script.cs. After this is done, it’s possible to use the
Script class like this:
var script = new Script();
script.Code = "using System.Windows.Forms; MessageBox.Show(\"Hello World!\");";
The second line in Script.cs contains the expression
#define TraceOpCode. If this is defined (currently only in DEBUG), the Debug Output window will show the current MSIL output.
For this simple example, it is only:
ldstr Hello World!
call System.Windows.Forms.DialogResult Show(System.String)
How It Works
System.Reflection.Emit contains the class DynamicMethod. This class exists since .NET FrameWork version 2.0.
It is possible to use the
DynamicMethod class to generate and execute methods at run time, without having to generate a dynamic assembly and a dynamic type to contain the method. Dynamic methods are the most efficient way to generate and execute small amounts of code. A good reference of how to use and an example code can be found here.
Script class encapsulates a simple array of Dynamic methods:
DynamicMethod methods. Every script function and the script body as creator is compiled to one of the dynamic methods in this array.
For this, the
Script class contains the
private helper class
Script.Compiler to translate the script code to MSIL instructions using the ILGenerator from
After this own compilation, the .NET Framework just-in-time (JIT) compiler can translate the MSIL instructions to native machine code.
In difference to script interpreters, we get fast machine code for each supported CPU architecture.
The current compiler version has no implementation for switch and while. However, the same functionality is possible with if and for statements. There is o support for native unsafe pointers. Alternatively, the compiler implemented in C# is easy to extend for such and other requirements.
I would appreciate any feedback you can give me on the code, concept, or the article itself.
Also, I'm curious about your ideas for enhancements and if you implement this concept what was the result.
- 10th May, 2011: Initial post