OoasTools

/*code taken from: http://www.codeproject.com/csharp/RuntimeCompiling.asp*/

using System;

using System.Text;

using Microsoft.CSharp;

using System.CodeDom.Compiler;

using System.Reflection;

namespace TUG.Mogentes

{

    /// <summary>

    /// This class can be used to execute dynamic uncompiled code at runtime

    /// This class is not exception safe, all function calls should be exception handled.

    /// </summary>

    public class CSharpCodeCompiler

    {

        /// <summary>

        /// This is the main code execution function.

        /// It allows for any compilable c# code to be executed.

        /// </summary>

        /// <param name="code">the code to be compiled then executed</param>

        /// <param name="namespacename">the name of the namespace to be executed</param>

        /// <param name="classname">the name of the class of the function in the code that you will execute</param>

        /// <param name="functionname">the name of the function that you will execute</param>

        /// <param name="isstatic">True if the function you will execute is static, otherwise false</param>

        /// <param name="args">any parameters that must be passed to the function</param>

        /// <returns>what ever the executed function returns, in object form</returns>

        public static object ExecuteCode(Assembly asm, string namespacename, string classname,

            string functionname, params object[] args)

        {

            // Assembly asm = BuildAssembly(code, new string[] {"System.dll", "SepiasTool.exe"});

            object instance = null;

            object returnval = null;

            Type type = asm.GetType(namespacename + "." + classname);

            System.Reflection.MethodInfo method = type.GetMethod(functionname);

            if (!method.IsStatic)

            {

                instance = asm.CreateInstance(namespacename + "." + classname);

            }

            returnval = method.Invoke(instance, args);

            return returnval;

        }

        /// <summary>

        /// This private function builds the assembly file into memory after compiling the code

        /// </summary>

        /// <param name="code">C# code to be compiled</param>

        /// <returns>the compiled assembly object</returns>

        ///

        public static Assembly BuildAssembly(string [] code, string[] referencedassemblies)

        {

            CodeDomProvider provider = new CSharpCodeProvider();

            CompilerParameters compilerparams = new CompilerParameters();

            compilerparams.GenerateExecutable = false;

            compilerparams.GenerateInMemory = true;

            compilerparams.ReferencedAssemblies.AddRange(referencedassemblies);

            CompilerResults results = provider.CompileAssemblyFromSource(compilerparams, code);

            if (results.Errors.HasErrors)

            {

                StringBuilder errors = new StringBuilder("Compiler Errors :\r\n");

                foreach (CompilerError error in results.Errors)

                {

                    errors.AppendFormat("Line {0},{1}\t: {2}\n", error.Line, error.Column, error.ErrorText);

                }

                throw new UlyssesCompileException(errors.ToString());

            }

            else

            {

                return results.CompiledAssembly;

            }

        }

    }

}