Click here to Skip to main content
12,243,721 members (44,330 online)
Click here to Skip to main content

Stats

11.9K views
327 downloads
15 bookmarked
Posted

Entity mapping language implementation using bsn-goldparser with CodeDom

, 6 Apr 2012 CPOL
Use the GOLD Parser to define a language for mapping between two business entities, create a parser using the bsn-goldparser engine, and generate an assembly using CodeDom.
EntityMapper
bsn.GoldParser
bin
Debug
Grammar
obj
Debug
TempPE
Parser
Properties
Semantic
GoldRuleDeclaration.cgt
GoldRuleDeclaration.grm
Xml
EntityMapper
bin
Debug
EntityMapper.vshost.exe
EntityMapper.vshost.exe.manifest
CodeGen
EntityMapper.csproj.user
Model
MyTest.suo
obj
x86
Debug
Properties
Semantic
EntityTransformation.cgt
EntityTransformation.grm
Service
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);
        }
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

matthew_from_hk
Founder
Hong Kong Hong Kong
I am always interested in finding innovative ways for building better applications and founded a technology company since 2003. Welcome to exchange any idea with you and if I am not too busy before deadline of projects, I will reply your emails. Also, if you willing to pay for consulting works and customized software development, you can leave me message.

You may also be interested in...

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.160426.1 | Last Updated 7 Apr 2012
Article Copyright 2012 by matthew_from_hk
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid