学步园

CLR自带了各种语言的编译器，例如C#、VB等。通过这些编译器以及反射，可以实现以前在其它环境中做不到的事情：运行时代码生成和编译。

作为一个应用，我们以对象工厂作为示例。对象工厂是通过一些标识符，在运行时生成不同对象的一种设计模式，通常的代码形式为：

    

public class ObjectFactory 
{ 
    public static object CreateInstance(string id) 
    { 
        switch (id) 
        { 
        case “A”: 
            return new A(); 

        case “B”: 
            return new B(); 

        … 

        default: 
            return null; 
    } 
} 

这段代码非常好，但是存在一个问题是，这是一段源代码，要想在运行时动态增加可以创建的对象就做不到。一种场景就是需要创建的对象是通过配置文件来确定的，那么就不能使用这种方式了。

CLR环境下反射的存在可以非常方便地实现动态工厂，例如：    

public class ObjectFactory2 
{ 
    public static object CreateInstance(string id) 
    { 
        Type type = Type.GetType(id); 

        return Activator.CreateInstance(type); 
    } 
} 

这里要求id是一个CLR类型名称。看上去很漂亮的代码，问题是这段代码非常慢，比前一段代码慢一万倍以上——原因在于在.NET中，几乎所有的反射都会涉及到对虚拟机本身的调用，而这种调用是通过COM进行的。此外还涉及到对整个类型系统的搜索等开销也是很庞大的。

第三种方案，使用一个Hash表以及配合委托进行。在系统初始化的时候创建一个Hash表，表的键为对象标识符，表的值为对象的类型，这样代码就会变成：

public class ObjectFactory3 
{ 
    public static Hashtable m_objectTypes; 

    public static object CreateInstance(string id) 
    { 
        Type type = m_objectTypes(id) as Type; 
        return Activator.CreateInstance(type); 
    } 
} 

在这段代码中，节省了Type.GetType的时间，但是并没有回避Activator.CreateInstance的代价，并且在大系统中，使用Hash表的效率也不是很高。

那么有没有更快、但是更加灵活的方式呢？回答是使用动态代码生成和编译技术。

想法是很简单的，我们还是回到第一种方式，switch语句，只要我们在运行时读入需要创建的对象标识符和对象类型，然而按照switch语句的语法创建一个C#源代码文件，然后编译，就可以了。这里涉及到几个问题：

1、 如何书写源代码：这实际上是很简单的，创建一个StringBuilder，然后往里面写字符串就可以了。然而为了提高代码的可读性和方便性，我们可以对其进行一些封装，例如下面这个接口可以完成大部分代码书写的工作。

public interface ICodeWriter 
{ 
    void WriteLine(); 
    void WriteLine(int count); 
    void WriteLine(string s); 
    void WriteLine(string s, params object[] args); 
    void Write(string s); 
    void Write(string s, params object[] args); 
    void CommentLine(); 
    void CommentLine(int count); 
    void CommentLine(string s); 
    void CommentLine(string s, params object[] args); 
    void Indent(); 
    void Indent(int count); 
    void UnIndent(); 
    void UnIndent(int count); 
    void WriteIndents(); 
} 

2、 如何组织源代码：基本上，我们需要下面这些信息： 
    a) 生成的工厂名称，以及工厂所需要实现的接口； 
    b) 需要生成的最终对象的类型，在第一个示例中，最终对象的类型是object，然而我们也可以用其它类型来代替，一个比较好的方式是使用一个所有要创建对象的公共基类类型； 
    c) 对象标识符：这是一个字符串数组，包含所有对象的标识符； 
    d) 对象类型：这是一个字符串数组或者类型数组，包含所有要创建的对象类型名称或者类型。

有了这些信息以后，我们就可以编写这个工厂的创建程序了：

public class ObjectFactoryBuilder 
{ 
    public static string CreateObjectFactorySource(string factoryName, string factoryBaseName, string baseProductName, string [] productIds, string [] productTypes) 
    { 
        ICodeWriter writer = new CSharpWriter(); 

        writer.WriteLine("public classs {0}: {1}”, factoryName, factoryBaseName); 
        writer.Indent(); 
        writer.WriteLine("public {0} CreateInstance(string id)”, baseProductName); 
        writer.Indent(); 

        writer.WriteLine("switch (name)"); 
        writer.Indent(); 
        for (int k = 0; k< productsIds.Length; ++k) 
        { 
            Writer. WriteLine("case \"{0}\": return new {1}();”, productsIds[k], productTypes[k]); 
        } 
        Writer.WriteLine("default: return null;"); 
        Writer.Unindent(3); 

        return Writer.ToString(); 
    } 
} 

上面这段代码就可以根据传入的信息，自动生成符合C#语法的源代码。

3、 如何编译：在 System.CodeDom.Compiler名字空间中包含了基本的编译器支持，Microsoft.CSharp名字空间中提供了C#编译器的实际对象。首先创建一个CompilerParameter对象，设置编译选项，然后用下面语句创建编译器并且编译代码：

CompilerParameters cp = new CompilerParameters(); 
// 设置 cp.ReferencedAssemblies 
CodeDomProvider provider = new CSharpCodeProvider(); 
CompileResult cr = provider.CompileAssemblyFromSource(cp, source); 

其中，source是一个字符串，包含从CreateObjectFactorySource得到的工厂源代码。如果编译成功，那么cr.Errors.Count == 0，编译生成的配件就是cr.CompiledAssembly。假设我们的工厂名字是ObjectFactory4，实现的接口是IObjectFactory，那么得到配件后，可以写：

Assembly asm = cr.CompiledAssembly; 
IObjectFactory factory = asm.CreateInstance("ObjectFactory4") as IObjectFactory; 

基于这种工作模式，我们需要在我们自己的配件中定义一个基类或者接口IObjectFactory，然后让动态生成的工厂继承基类或者实现接口，这样我们就可以调用这个工厂来创建对象了。