EXECUTION-TIME CODE GENERATION in Visual C#.NET

Generation PDF417 in Visual C#.NET EXECUTION-TIME CODE GENERATION

CodeBinaryOperatorExpression add = new CodeBinaryOperatorExpression(); multiply.Right = add; add.Operator = CodeBinaryOperatorType.Add; add.Left = new CodePrimitiveExpression(coefficients[i]); current = add; } current.Right = new CodePrimitiveExpression(0.0); // return the expression... eval.Statements.Add(new CodeMethodReturnStatement(plus)); polyClass.Members.Add(eval); cg.GenerateCodeFromType(polyClass, t, op); t.Close(); s.Close(); //compile the DLL CompilerParameters compParams = new CompilerParameters(); compParams.CompilerOptions = "/target:library /o+"; compParams.ReferencedAssemblies.AddRange(new string[] {Path.GetFileName(Assembly.GetExecutingAssembly().CodeBase), "mscorlib.dll", "System.dll"}); compParams.IncludeDebugInformation = false; compParams.GenerateInMemory = false; compParams.OutputAssembly = (filename + ".dll"); CompilerResults res = provider.CompileAssemblyFromFile(compParams, filename + ".cs"); // Open the file, create the instance, and cast it // to the assembly Assembly a = Assembly.LoadFrom(filename + ".dll"); polynomial = (IPolynomial) a.CreateInstance(className); File.Delete(filename + ".cs"); } public override IPolynomial GetEvaluate() { if (polynomial == null) WriteCode(); return((IPolynomial) polynomial); }

public override double Evaluate(double value) { return(0.0); // not used } IPolynomial polynomial = null; static int polyNumber = 1000; } Because the approach is the same, this technique yields similar performance.

With a bit more digging in the documentation, you may come across the Reflection.Emit namespace. Using the classes in this namespace, it s possible to create classes in memory and write the IL for the functions directly. Using Reflection.Emit is fairly challenging because functions are written in the IL language rather than in C#. IL is roughly as difficult to develop in as assembly language, though the .NET IL is quite a bit simpler than x86 assembly language. The IL reference guide that ships with the SDK will be a useful reference.1 The easiest way to determine what IL to generate is to write the class in C#, compile it, and then use ILDASM to figure out what IL to generate. To evaluate the polynomial expression, the C# compiler uses a regular pattern, so generating the IL is straightforward. Here s the class that does it: using using using using using using using System; System.IO; System.Diagnostics; System.Reflection; System.Reflection.Emit; System.Threading; PolyInterface;

class PolyEmit: Polynomial { Type theType = null; object theObject = null; IPolynomial poly = null; public PolyEmit(params double[] coefficients): base(coefficients) { } /// <summary> /// Create an assembly that will evaluate the polynomial. /// </summary>

private Assembly EmitAssembly() { // // Create an assembly name // AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = "PolynomialAssembly"; // // Create a new assembly with one module // AssemblyBuilder newAssembly = Thread.GetDomain().DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run); ModuleBuilder newModule = newAssembly.DefineDynamicModule("Evaluate"); // // Define a public class named "PolyEvaluate" in the assembly. // TypeBuilder myType = newModule.DefineType("PolyEvaluate", TypeAttributes.Public); // // Mark the class as implementing IPolynomial. This is // the first step in that process. // myType.AddInterfaceImplementation(typeof(IPolynomial)); // Add a constructor ConstructorBuilder constructor = myType.DefineDefaultConstructor(MethodAttributes.Public); // // Define a method on the type to call. We pass an // array that defines the types of the parameters, // the type of the return type, the name of the method, // and the method attributes. // Type[] paramTypes = new Type[] {typeof(double)}; Type returnType = typeof(double); MethodBuilder simpleMethod = myType.DefineMethod("Evaluate", MethodAttributes.Public | MethodAttributes.Virtual, returnType, paramTypes);

// // From the method, get an ILGenerator. This is used to // emit the IL that we want. // ILGenerator il = simpleMethod.GetILGenerator(); // // Emit the IL. This is a hand-coded version of what // you'd get if you compiled the code example and then ran // ILDASM on the output. // // // This first section repeated loads the coefficient's // x value on the stack for evaluation. // for (int index = 0; index < coefficients.Length - 1;index++) { il.Emit(OpCodes.Ldc_R8, coefficients[index]); il.Emit(OpCodes.Ldarg_1); } // load the last coefficient il.Emit(OpCodes.Ldc_R8, coefficients[coefficients.Length - 1]); // Emit the remainder of the code. This is a repeated // section of multiplying the terms together and // accumulating them. for (int loop = 0; loop < coefficients.Length - 1; loop++) { il.Emit(OpCodes.Mul); il.Emit(OpCodes.Add); } // return the value il.Emit(OpCodes.Ret); // // Finish the process. // Create the type. // //myType.CreateType();