C# 动态编译

　　现在也接触一下动态编译吧!去年也听说过了，但是只瞄了一眼，没去实践，不久前有同事在介绍动态编译，那时我因为某些原因没法去听听。现在就看一下

　　整个编译过程最基本用到两个类CodeDomProvider类和CompilerParameters 类。前者就充当一个编译器，后者则是用于记录传递给编译器的一些参数。在最初学习C#的使用，鄙人没有用得上VS，只能靠CSC，那么CSC就类似于CodeDomProvider这个类，而CSC本身会有不少命令参数，CompilerParameters 类就能为CSC传递一些编译信息（生成类型，引用程序集等）。那么下面则尝试用最简单的方式看看这个动态编译。

       public static void TestMain()
        {
            _default = new CompilTest();
            _default.SimpleCompile(code);
        }

       static CompilTest _default;


        CodeDomProvider compiler;
        CompilerParameters comPara;
        const string code=@"using System;

class Test
{
static void Main()
{
Console.WriteLine(""Hello world"");
Console.ReadLine();
}
}";

        private CompilTest()
        {
            compiler = new CSharpCodeProvider();
            comPara = new CompilerParameters();
        }



        public void SimpleCompile(string code)
        {
            comPara.GenerateExecutable = true;
            comPara.GenerateInMemory = false;
            comPara.OutputAssembly = "SimpleCompile.exe";

            compiler.CompileAssemblyFromSource(comPara, code);
        }

然后跑到当前运行程序的目录下就能找到生成的可执行文件SimpleCompile.exe。这个就是最简单的动态编译。

　　上面CompilerParameters 类的示例设置了三个属性，GenerateExecutable是设置编译后生成的是dll还是exe，true是dll，false是exe，默认是生成dll的。OutputAssembly则是设置生成文件的文件名。对于GenerateInMemory这个属性，MSDN上说的是true就把编译的生成的程序集保留在内存中，通过CompilerResults实例的CompiledAssembly可以获取。如果设为false则是生成文件保存在磁盘上，通过CompilerResults实例的PathToAssembly实例获取程序集的路径。但是经我实践，无论GenerateInMemory设置哪个值，都会在硬盘上生成相应的文件，区别在于OutputAssembly设置了相应的文件名的话，生成的文件会存在指定路径上，否则会存放在系统的临时文件夹里面。都可以通过CompiledAssembly获取生存的程序集。GenerateInMemory设值区别在于设置了true，PathToAssembly的值为null，false就能获取生成文件的路径。不过该类还有些比较有用的属性没用上，ReferencedAssemblies属性设置编译时要引用的dll；MainClass属性设置主类的名称，假设要编译的代码中包含了多个带有Main方法的类，生成的程序采用就近原则只执行第一个Main方法，如果要执行别的类的Main方法的时候，就可以通过MainClass来设置。

　　CodeDomProvider只是一个抽象类而已，对于不同的程序语言，有相应的类去继承这个抽象类，C#的就是CSharpCodeProvider类。用于编译的方法有三个，方法的声明如下

public virtual CompilerResults CompileAssemblyFromDom(CompilerParameters options, params CodeCompileUnit[] compilationUnits);
public virtual CompilerResults CompileAssemblyFromFile(CompilerParameters options, params string[] fileNames);
public virtual CompilerResults CompileAssemblyFromSource(CompilerParameters options, params string[] sources);

　　上面用到的是CompileAssemblyFromSource，传进去第二个参数是需要编译的代码字符串。而第二个方法传入的参数是需要编译的代码文件名。以上三个方法都返回同一个值——一个CompilerResults的实例。通常这个示例可以知道编译是否通过，如果失败了错误的代码的位置，更重要的是可以获取编译成功的程序集。当编译成功之后，要么就通过反射来调用生成好的东西，要么就直接开启进程去执行exe。

　　那么上面还有一个方法没介绍，这个方法的参数是CodeCompileUnit，这个类MSDN上的解释是为 CodeDOM 程序图形提供容器。但个人感觉它可以说是一个代码的构造器，CompileAssemblyFromFile方法和CompileAssemblyFromSource方法无论代码来自文件还是字符串，它都是确确实实的C#代码，但是用了CodeCompileUnit就感觉通过配置的形式来经行编程，而不是逐行逐行地写。先看看下面代码，定义了三个方法，一个是构造CodeCompileUnit实例，其余两个方法是生成C#代码并输出到文件和编译生成

        private CodeCompileUnit CreateUnitTest()
        {
            CodeCompileUnit unit = new CodeCompileUnit();

            //命名空间设置
            CodeNamespace codeNamespace = new CodeNamespace("TestNameSpace");//设置命名空间名字
            codeNamespace.Imports.Add(new CodeNamespaceImport("System"));//引用的命名空间
            unit.Namespaces.Add(codeNamespace);

            //类的定义
            CodeTypeDeclaration testClass = new CodeTypeDeclaration("TestClass");//类名
            testClass.Attributes= MemberAttributes.Public;
            testClass.CustomAttributes.Add(new CodeAttributeDeclaration("Serializable"));//类的Attributes
            codeNamespace.Types.Add(testClass);

            //字段定义
            CodeMemberField strMember = new CodeMemberField("String", "str1");
            strMember.Attributes= MemberAttributes.Private;
            testClass.Members.Add(strMember);

            CodeMemberField _default = new CodeMemberField("TestClass", "_default");
            _default.Attributes = MemberAttributes.Private | MemberAttributes.Static;
            _default.InitExpression = new CodeSnippetExpression("new TestClass("hello world")");
            testClass.Members.Add(_default);

            //构造函数定义
            CodeConstructor constructor = new CodeConstructor();
            constructor.Attributes = MemberAttributes.Public;
            constructor.Parameters.Add(new CodeParameterDeclarationExpression("String", "para1"));
            constructor.Statements.Add(new CodeSnippetStatement("str1=para1;"));
            testClass.Members.Add(constructor);

            //方法定义
            CodeMemberMethod method = new CodeMemberMethod();
            method.Name = "Print";
            method.Attributes = MemberAttributes.Static | MemberAttributes.Public;
            CodeParameterDeclarationExpression para1 = new CodeParameterDeclarationExpression("String", "str");
            method.Parameters.Add(para1);
            method.ReturnType = new CodeTypeReference(typeof(void));
            CodeTypeReferenceExpression csSystemConsoleType = new CodeTypeReferenceExpression("System.Console");
            CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(
                csSystemConsoleType, "WriteLine", 
                new CodeArgumentReferenceExpression("str"));
            method.Statements.Add(cs1);
            testClass.Members.Add(method);

            //程序入口定义 Main方法
            CodeEntryPointMethod mainMethod = new CodeEntryPointMethod();
            mainMethod.Attributes = MemberAttributes.Public;
            CodeTypeReferenceExpression csMethodCall = new CodeTypeReferenceExpression("TestNameSpace.TestClass");
            cs1 = new CodeMethodInvokeExpression(csMethodCall, "Print", new CodeTypeReferenceExpression("_default.str1"));
            mainMethod.Statements.Add(cs1);
            testClass.Members.Add(mainMethod);

            return unit;
        }

        private void Compile(CodeCompileUnit unit)
        {
            comPara.GenerateExecutable = true;
            comPara.GenerateInMemory = true;
            comPara.OutputAssembly = "SimpleCompile.exe";
            //comPara.MainClass = "Test2";

            CompilerResults result = compiler.CompileAssemblyFromDom(comPara, unit);

            if (result.Errors.Count == 0)
            {
                Assembly assembly = result.CompiledAssembly;
                Type AType = assembly.GetType("TestNameSpace.TestClass");
                MethodInfo method = AType.GetMethod("Main", BindingFlags.Static | BindingFlags.Public);
                Console.WriteLine(method.Invoke(null, null));
            }
            else
            {
                foreach (CompilerError item in result.Errors)
                {
                    Console.WriteLine(item.ErrorText);
                }
            }
        }

        private void CreteCodeFile(CodeCompileUnit unit, string fileName)
        {
            StringBuilder sb=new StringBuilder();
            using (StringWriter  tw=new StringWriter(sb))
            {
                compiler.GenerateCodeFromCompileUnit(unit, tw, new CodeGeneratorOptions());
            }
            File.WriteAllText(fileName, sb.ToString());
        }

　　上面代码我觉得的重点在于构造CodeCompileUnit，在MSDN上对GenerateCodeFromCompileUnit的描述是：基于包含在 CodeCompileUnit 对象的指定数组中的 System.CodeDom 树，使用指定的编译器设置编译程序集。这里有个DOM我想起了JS对HTML的DOM树，不过在构造整个CodeCompileUnit过程中，也感觉到树的层次结构，一个code文件里面有多个命名空间，命名空间里面又有多种类型（类，接口，委托），类型里面又包含各自的成员（字段，属性，方法），方法里面包含了语句，语句里面又包含了表达式。

但是这种方式从开发人员而言代码量加大了。

　　这篇也是营养不多，不上博客园首页了。