
Introduction
There are several languages out there (primarily interpreted languages) which provide a convenient eval
statement or function. These usually accept simple fragments of code and execute them on the fly, often used for mathematical expressions. .NET leaves this useful feature out of its BCL (Base Class Library), and buries access to its compiler under incomplete documentation. I was working on a project of my own when I realized that I needed some form of runtime compilation, and went off on a tangent to build an easy-to-use library (also adding full XML documentation).
Using the code
The library is centered around the Eval
class, which contains the static
methods that access the compiler.
The methods provided are as follows:
public static AssemblyResults CreateAssembly(ICodeCompiler compiler,
string assemblySource,
CompilerParameters options,
Language language);
public static TypeResults CreateType(ICodeCompiler compiler,
string typeSource,
string typeName,
CompilerParameters options,
Language language);
public static MethodResults CreateMethod(ICodeCompiler compiler,
string methodSource,
string methodName,
CompilerParameters options,
Language language);
public static AssemblyResults CreateVirtualAssembly(ICodeCompiler compiler,
string assemblySource,
bool debug,
Language language,
params string[] references);
public static TypeResults CreateVirtualType(ICodeCompiler compiler,
string typeSource,
string typeName,
Language language,
bool debug,
params string[] references);
public static MethodResults CreateVirtualMethod(ICodeCompiler compiler,
string methodSource,
string methodName,
Language language,
bool debug,
params string[] references);
Each method compiles the source provided, loads the result into memory, and returns a reference to an object wrapping the final result (along with any warnings generated by the compiler). If any errors are generated during the compilation, a CompilationException
is thrown, which contains the compiler's errors. The "Virtual" group of methods stores the results of compilation directly to memory, using a pre-generated set of CompilerParameters
.
The Language
class and its subclasses provide information about an individual language to the Eval
class, exposing methods that generate various language-specific segments of the code which are necessary in the CreateType
and CreateMethod
methods of the Eval
class.
The result classes each expose the actual result through a property named by the type of the result (respectively through the Assembly
, Type
, and Method
properties), as well as the collection of warnings generated during compilation (through the Warnings
property). In addition, each class provides indirect access to some of the more commonly used abilities of its underlying result (each of which acts as described in its XML documentation).
The AssemblyResult
class provides the following method:
public TypeResults GetType(string typeName, bool throwOnError);
The TypeResults
class provides the following methods:
public MethodResults GetMethod(string name);
public MethodResults GetMethod(string name,
params Type[] paramTypes);
public object Instantiate(params object[] parameters);
Finally, the MethodResults
class provides the following method:
public object Invoke(params object[] parameters);
This method automatically creates an instance of the declaring class on which to invoke the wrapped method, allowing non-static methods to be invoked as if they were static
.
Points of interest
Microsoft included nearly everything that I needed to write this library in their standard .NET Framework, except the final wrapper. If you find that you need something beyond the capabilities of my library, the System.CodeDom.Compiler
and System.Reflection
namespaces should provide most of what you need.
To do
More than a few things, most likely... Currently only one update comes to mind. If there is any demand for it, I will make the results of my runtime compilation interface unloadable from memory by using AppDomains (inspired by and probably borrowing from the DevX article Dynamically Executing Code in .NET).
This is my first article posted, so I'd appreciate any feedback. E-mail feedback is accepted, but I'd prefer feedback through the message board provided by the CodeProject.
History
- 12th January, 2006
- Updated code (again) to fix a bug with referenced libraries and an issue with in-memory compilation. Both features should now work as intended.
- 6th December, 2003
- Refactored code (added
Language
class and subclasses, updated Eval
class) in order to make the Eval
class work fully with languages other than C#, added VB.NET example, and updated the article to reflect these changes.
- 14th January, 2003
- Updated code to fix minor bugs with referenced libraries.
- 11th January, 2003
- Zip files finally corrected (extensive paths removed).
- 2nd January, 2003
- Example project, screenshot, and To do added, a few bugs fixed.
- 31st December, 2002:
- Article first posted.
- ~5:31 PM EST:
<pre>
blocks fixed (Sorry!).