.Net Expression Evaluator using DynamicMethod.(转于CodeProject)

.Net Expression Evaluator using DynamicMethod
ByWilson, Drew.
Evaluating Dynamic expressions by compiling C# code to IL, then creating a DynamicMethod from the IL.
C# (C# 2.0)
Windows, .NET
Win32, VS (VS2005)
Dev
Posted: 13 Mar 2007
Views: 998

Search       Advanced Search
Sitemap |Add to IE Search
Download source - 36 Kb

Introduction
There are already quite a few articles about dynamic expression evaluation using .NET. What I want to show here is a new twist on the idea by using the DynamicMethod class in the System.Reflection.Emit namespace. In my research I‘ve found two main ways to tackle runtime expression evaluation: compile .NET code using the System.CodeDom namespace or write a parser. There are pros and cons with each method but I knew I didn‘t want to have to write a parser since .NET can already parse C# and will do a much better job at it than I can.
The good thing about compiled code is it‘s fast. However, there are several problems with it. It seems to take quite a bit of time to compile compared to parsing. So if the expression is constantly changing then it won‘t be a good performer. But if the expression is something to be compiled once and called many times then its performance can‘t be beat. So this is the problem I‘m trying to solve; given a set of expressions I need to execute them quickly for a given set of values or row of data. Then be able to do the same for a data set by repeating for each row in the set.
Background
Some useful articles/sites I‘ve found:
Parsing the IL of a Method Body
Turn MethodInfo to DynamicMethod
The expression evaluator revisited (Eval function in 100% managed .net)
Evaluating Mathematical Expressions by Compiling C# Code at Runtime
A Math Expression Evaluator
It would be a good idea to look at some of these to get an idea of how this article differs or on what concepts it‘s based.
So a problem with CodeDom is that compiling causes the resultant assembly to be loaded into the current AppDomain. Since in .NET you can‘t unload an assembly you would end up with a lot of assemblies since a new one is created for each new expression. To keep the generated assembly from being loaded right away another AppDomain can be created where code the is generated. But when we want to execute the expression the assembly still has to be loaded. So what can we do to get around this problem? Enter System.Reflection.Emit.DynamicMethod class to save the day.
By now I‘m sure you just looked inMSDN to find out more about it. DynamicMethod allows a method to be created at runtime and have the speed of compiled code. This is great but just one problem: you need to write the IL code for it.
I knew I didn‘t want to write a parser and I sure didn‘t want to spend a lot of time with writing IL code. The bright idea comes from theTurn MethodInfo to DynamicMethod article linked above. Basically reflection can be used to get the IL code of a compiled method and generate a DynamicMethod from it. Perfect! Now we can write .NET code, compile it, get the IL code and create the DynamicMethod we need.
Using the code
To turn a MethodInfo into a DynamicMethod I needed to know what method was being used. I know I wanted access to functions in the same class as the method, so I didn‘t need to prefix with a class name. I wanted to provide a set of documented functions to the user without them having to know a lot of .NET. So I created an object with some functions on it and called it FunctionClass.
public class FunctionClass { //some instance data, could be another object //maybe a datarow or custom data object public double X; public double Y; public double Z; //method that can be called public double Round(double number) { return Math.Round(number); } } CodeDom Compiler
So to compile a C# expression that will have access to the methods on this class I‘m going to make the compiled method on a class that inherits from FunctionClass. This way it will have access to all protected and public methods from the base class and call them without any type prefix. The assumption I‘ve made is that an expression is one line of code so it looks like return [user code line];. To keep it type safe I‘m also going to require that the user pick a return type for the expression; double, string, DateTime, etc. So below is the code for the compiler class.
Collapse
///

/// Expression compiler using the C# language ///

public class CSharpExpressionCompiler : BaseExpressionCompiler, IExpressionCompiler { ///

/// Compiles the expression into an assembly and returns the method code /// for it. /// It should compile the method into a class that inherits from the /// functionType. ///

/// expression to be /// compiled /// Type of the function class /// to use /// Return type of the method to /// create /// DynamicMethodState - A serialized version of the /// method code public DynamicMethodState CompileExpression(string expression, Type functionType, Type returnType) { DynamicMethodState methodState; //use CodeDom to compile using C# CodeDomProvider codeProvider = CodeDomProvider.CreateProvider("CSharp"); CompilerParameters loParameters = new CompilerParameters(); //add assemblies loParameters.ReferencedAssemblies.Add("System.dll"); loParameters.ReferencedAssemblies.Add(functionType.Assembly.Location); //don‘t generate assembly on disk and treat warnings as errors loParameters.GenerateInMemory = true; loParameters.TreatWarningsAsErrors = true; //set namespace of dynamic class string dynamicNamespace = "ExpressionEval.Functions.Dynamic"; //set source for inherited class - need to change to use CodeDom //objects instead string source = @" using System; using {5}; namespace {6} {{ public class {0} : {1} {{ public {2} {3}() {{ return {4}; }} }} }} "; //set source code replacements string className = "Class_" + Guid.NewGuid().ToString("N"); string methodName = "Method_" + Guid.NewGuid().ToString("N"); string returnTypeName = returnType.FullName; //check for generic type for return .... //format codestring with replacements string codeString = string.Format(source, className, functionType.FullName, returnTypeName, methodName, expression, functionType.Namespace, dynamicNamespace); //compile the code CompilerResults results = codeProvider.CompileAssemblyFromSource(loParameters, codeString); if (results.Errors.Count > 0) { //throw an exception for any errors throw new CompileException(results.Errors); } else { //get the type that was compiled Type dynamicType = results.CompiledAssembly.GetType( dynamicNamespace + "." + className); //get the MethodInfo for the compiled expression MethodInfo dynamicMethod = dynamicType.GetMethod(methodName); //get the compiled expression as serializable object methodState = GetMethodState(dynamicMethod); } return methodState; } }
The BaseExpressionCompiler provides the GetMethodState method that converts a MethodInfo into a DynamicMethodState. DynamicMethodState is the class that provides a serializable form of a method‘s IL and metadata token offsets. Once I have that I can throw away the assembly that was created.
Collapse
///

/// A base expression compiler. MarshalByRef so it can be used across /// AppDomains. ///

public abstract class BaseExpressionCompiler : MarshalByRefObject { ///

/// Converts a MethodInfo into a serialized version of it. ///

/// The method for which to /// create a DynamicMethod for /// DynamicMethodState - serialized version of a /// method. protected DynamicMethodState GetMethodState(MethodInfo dynamicMethod) { DynamicMethodState methodState = new DynamicMethodState(); //IL info from method MethodBody methodIlCode = dynamicMethod.GetMethodBody(); //get code bytes and other method properties methodState.CodeBytes = methodIlCode.GetILAsByteArray(); methodState.InitLocals = methodIlCode.InitLocals; methodState.MaxStackSize = methodIlCode.MaxStackSize; //get any local variable information IDictionary locals = new SortedList(); foreach (LocalVariableInfo localInfo in methodIlCode.LocalVariables) { locals.Add(localInfo.LocalIndex, new LocalVariable(localInfo.IsPinned, localInfo.LocalType.TypeHandle)); } methodState.LocalVariables = locals; TokenOffset tokenOffset = new TokenOffset(); //get metadata token offsets IlReader reader = new IlReader(methodState.CodeBytes, dynamicMethod.Module); tokenOffset.Fields = reader.Fields; tokenOffset.Methods = reader.Methods; tokenOffset.Types = reader.Types; tokenOffset.LiteralStrings = reader.LiteralStrings; methodState.TokenOffset = tokenOffset; return methodState; } }
The compiler class inherits from MarshalByRefObject because it needs to be used across an AppDomain as explained earlier. Now that there is a compiler to get a DynamicMethodState we then need to create the DynamicMethod object from it.
DynamicMethod Delegate
The ExpressionDelegateFactory calls to the compiler across an AppDomain it creates to compile an expression. It then creates a delegate from the DynamicMethodState returned by the compiler in the form of R ExecuteExpression(C functionClass) where R is the return type and C is the function class type.
Collapse
///

/// Implements a Delegate Factory for compiled expressions ///

public class ExpressionDelegateFactory : IExpressionDelegateFactory { private ExpressionLanguage m_language; ///

/// Delegate Factory for a Language ///

/// public ExpressionDelegateFactory(ExpressionLanguage language) { m_language = language; } ///

/// Compiles an expression and returns a delegate to the compiled code. ///

/// The return type of the /// expression /// The type of the function /// class /// Expression to /// evaluate /// ExecuteExpression - a delegate that calls /// the compiled expression public ExecuteExpression CreateExpressionDelegate(string expression) { ExecuteExpression expressionDelegate = null; DynamicMethodState methodState; //create the compiled expression methodState = CreateExpressionMethodState(expression); if (methodState != null && methodState.CodeBytes != null) { //get a dynamic method delegate from the method state expressionDelegate = CreateExpressionDelegate(methodState); } return expressionDelegate; } ///

/// Compiles an expression and returns a DynamicMethodState ///

/// The return type of the /// expression /// The type of the function /// class /// Expression to /// evaluate /// DynamicMethodState - serialized version of the /// compiled expression public DynamicMethodState CreateExpressionMethodState(string expression) { DynamicMethodState methodState; IExpressionCompiler compiler; //create an AppDomain AppDomainSetup loSetup = new AppDomainSetup(); loSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory; AppDomain loAppDomain = AppDomain.CreateDomain("CompilerDomain", null, loSetup); //get the compiler to use based on the language string className = null; switch(m_language) { case ExpressionLanguage.CSharp: className = "CSharpExpressionCompiler"; break; case ExpressionLanguage.VisualBasic: className = "VisualBasicExpressionCompiler"; break; case ExpressionLanguage.JScript: className = "JScriptExpressionCompiler"; break; } //create an instance of a compiler compiler=(IExpressionCompiler)loAppDomain.CreateInstanceFromAndUnwrap( "ExpressionEval.ExpressionCompiler.dll", "ExpressionEval.ExpressionCompiler." + className); try { //compile the expression methodState = compiler.CompileExpression(expression, typeof(C), typeof(R)); } catch (CompileException e) { //catch any compile errors and throw an overall exception StringBuilder exceptionMessage = new StringBuilder(); foreach (CompilerError error in e.CompileErrors) { exceptionMessage.Append("Error# ").Append(error.ErrorNumber); exceptionMessage.Append(", column ").Append(error.Column); exceptionMessage.Append(", ").Append(error.ErrorText); exceptionMessage.Append(Environment.NewLine); } throw new ApplicationException(exceptionMessage.ToString()); } finally { //unload the AppDomain AppDomain.Unload(loAppDomain); } //if for some reason the code byte were not sent then return null if (methodState != null && methodState.CodeBytes == null) { methodState = null; } return methodState; } ///

/// Compiles a DynamicMethodState and returns a delegate. ///

/// The return type of the /// expression /// The type of the function /// class /// The serialized version of a /// method on the functionClass /// ExecuteExpression - a delegate that calls /// the compiled expression public ExecuteExpression CreateExpressionDelegate(DynamicMethodState methodState) { ExecuteExpression expressionDelegate; //create a dynamic method DynamicMethod dynamicMethod = new DynamicMethod( "_" + Guid.NewGuid().ToString("N"), typeof(R), new Type[] { typeof(C) }, typeof(C)); //get the IL writer for it DynamicILInfo dynamicInfo = dynamicMethod.GetDynamicILInfo(); //set the properties gathered from the compiled expression dynamicMethod.InitLocals = methodState.InitLocals; //set local variables SignatureHelper locals = SignatureHelper.GetLocalVarSigHelper(); foreach (int localIndex in methodState.LocalVariables.Keys) { LocalVariable localVar = methodState.LocalVariables[localIndex]; locals.AddArgument(Type.GetTypeFromHandle(localVar.LocalType), localVar.IsPinned); } dynamicInfo.SetLocalSignature(locals.GetSignature()); //resolve any metadata tokens IlTokenResolver tokenResolver = new IlTokenResolver( methodState.TokenOffset.Fields, methodState.TokenOffset.Methods, methodState.TokenOffset.Types, methodState.TokenOffset.LiteralStrings); methodState.CodeBytes = tokenResolver.ResolveCodeTokens( methodState.CodeBytes, dynamicInfo); //set the IL code for the dynamic method dynamicInfo.SetCode(methodState.CodeBytes, methodState.MaxStackSize); //create a delegate for fast execution expressionDelegate = (ExecuteExpression)dynamicMethod.CreateDelegate( typeof(ExecuteExpression)); return expressionDelegate; } }
The ‘magic‘ for DynamicMethod is that it behaves like a static method except it can also be used like an instance method. In IL code the first argument in an instance method is always the instance of the type to which the method belongs. So to trick this static method to behave like an instance, you make sure the first argument of the method is an instance of the type to which the method belongs. Read about this inMSDN because its the important concept that makes this code work.
I also wanted to hide the implementation of creating a DynamicMethod from the code using the expression so I created an ExpressionEvaluator that wraps the calls to the ExpressionDelegateFactory. The code is separated into 5 different projects: MsilConversion (IL reading and token resolving), MethodState (shared dll between app domains, DynamicMethodState), ExpressionCompiler (langauge specific compilers), DynamicMethodGenerator (DynamicMethod delegate factory), ExpressionEvaluation (wrapper around delegate factory).
I created a Windows Forms test application aptly named TestApp to call the ExpressionEvaluation engine. It has a simple one-time Evaluate and then a Loop function that shows the performance that a ‘compile once, run many times‘ operation can achieve.
Possibilities
There appear to be quite a few possibilities from here for implementation enhancements or changes. Different .NET languages, a language translator from custom language to .NET language, supporting multiple code lines instead of a one line expression. Maybe being even more ambitious and creating a parser/IL generator to skip the CodeDom step and write IL directly.
Feedback
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.
History
3/13/2007 - First Published
About Wilson, Drew
.Net Software Engineer in Kansas, USA trying to keep pace with technology. Clickhere to view Wilson, Drew‘s online profile.
Other popular C# Programming articles:
A flexible charting library for .NET Looking for a way to draw 2D line graphs with C#? Here‘s yet another charting class library with a high degree of configurability, that is also easy to use.
I/O Ports Uncensored - 1 - Controlling LEDs (Light Emiting Diodes) with Parallel Port Controlling LEDs (Light Emiting Diodes) with Parallel Port
I/O Ports Uncensored Part 2 - Controlling LCDs (Liquid Crystal Displays) and VFDs (Vacuum Fluorescent Displays) with Parallel Port Controlling LCDs (Liquid Crystal Displays) and VFDs (Vacuum Fluorescent Displays) with Parallel Port
Asynchronous Method Invocation How to use .NET to call methods in a non-blocking mode.
[Top]Sign in to vote for this article:     PoorExcellent


Note: You mustSign in to post to this message board.
FAQ  Message score threshold 1.0 2.0 3.0 4.0 5.0    Search comments
View Normal (slow) Preview (slow) Message View Topic View Thread View Expanded (Supporters only)    Per page 10 25 50 (must logon)
  Total Messages for this article: 0 (Refresh)
Subject  Author  Date

-- No entries --

General comment   News / Info   Question   Answer   Joke / Game   Admin message