Entity mapping language implementation using bsn-goldparser with CodeDom

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.CodeDom;
using System.Reflection;
using System.CodeDom.Compiler;
using Microsoft.CSharp;


namespace EntityMapper.CodeGen
{
    public class CodeCompilerUtility
    {
        static Dictionary<string, Assembly> _assemblies;
        static Dictionary<string, Assembly> Assemblies
        {
            get
            {
                if (null == _assemblies)
                {
                    _assemblies = new Dictionary<string, Assembly>();
                }
                return _assemblies;
            }
        }

        public static string GenerateCSharpCode(CodeCompileUnit compileunit)
        {
            // Generate the code with the C# code provider.
            CSharpCodeProvider provider = new CSharpCodeProvider();

            // Create a TextWriter to a StreamWriter to the output file.
            using (TextWriter sw = new StringWriter())
            {
                IndentedTextWriter tw = new IndentedTextWriter(sw, "    ");

                // Generate source code using the code provider.
                provider.GenerateCodeFromCompileUnit(compileunit, tw,
                    new CodeGeneratorOptions());

                // Close the output file.
                tw.Close();

                return sw.ToString();
            }

        }

        public static Assembly CompileCodeDOM(CodeCompileUnit compileunit, string[] referencedAssemblies)
        {
            CSharpCodeProvider provider = new CSharpCodeProvider();

            // Build the parameters for source compilation.
            CompilerParameters cp = new CompilerParameters();

            // Add an assembly reference.
            cp.ReferencedAssemblies.AddRange(referencedAssemblies);

            // Generate a class library.
            cp.GenerateExecutable = false;

            // Save the assembly as a physical file.
            cp.GenerateInMemory = true;
            
            // Invoke compilation.
            var cr = provider.CompileAssemblyFromDom(cp, compileunit);
            if (cr.Errors.Count > 0)
            {
                // Display compilation errors.
                StringBuilder sb = new StringBuilder();

                foreach (CompilerError ce in cr.Errors)
                {
                    sb.AppendFormat("  {0}", ce.ToString());
                    sb.AppendLine();
                }

                throw new ApplicationException(sb.ToString());
            }

            // Return the results of compilation.
            return cr.Errors.Count == 0 ? cr.CompiledAssembly : null;
        }

        public static Delegate GetDelegateFromCompileUnit(string ccuKey, CodeCompileUnit compileunit, string[] referencedAssemblies, string typeName, string methodName, Type delegateType, bool refreshCache = false) 
        {
            Assembly assembly;
            if (!Assemblies.ContainsKey(ccuKey) || refreshCache)
            {
                assembly = CompileCodeDOM(compileunit, referencedAssemblies);
                if (Assemblies.ContainsKey(ccuKey)) {
                    Assemblies.Remove(ccuKey); 
                }
                Assemblies.Add(ccuKey, assembly);
            }
            else
            {
                assembly = Assemblies[ccuKey];
            }

            var type = assembly.GetType(typeName, true);
            var method = type.GetMethod(methodName);
            var obj = assembly.CreateInstance(typeName);
            return Delegate.CreateDelegate(delegateType, obj, method);
        }
    }
}