【.net 深呼吸】细说CodeDom（2）：表达式、语句

在上一篇文章中，老周厚着脸皮给大伙介绍了代码文档的基本结构，以及一些代码对象与CodeDom类型的对应关系。

在评论中老周看到有朋友提到了 Emit，那老周就顺便提一下。严格上说，Emit并不是针对代码文档生成和编译而设计的，Emit一方面可以实时发出 IL 指令，另一方面也支持动态程序集，即可以在运行时创建程序集，并可以定义类型，然后可以执行。而CodeDom所针对的是代码文档的生成和编译，所以说，是有所不同的。

哦，是了，还有一个玩意儿挺有趣，也提一下吧——动态 Linq 表达式树。它也跟动态编译有点像，就是动态创建 LINQ表达式树，LINQ懂吧，别告诉你不知道，这是玩.net的必备法宝，表达式树创建后会实时编译为一个委托实例，使用时直接调用生成的委托实例即可。

好，下面开始本文的内容。先说说表达式，因为语句是由表达式组成的，按照正常人类的思考方式，应当由小及大来学习。啥是表达式呢，其实可以说，表达式是代码文档的基础元素，比如一个int值 2500，就是一个表达式；字符串常量用双引号包起来，如"abc"，也是一个表达式；当前类实例的引用 this也是表达式；基类实例的引用 base，也是表达式；变量名 a 也是表达式；数组索引，如 [0] 也是表达式；方法中的输出参数 out 也是表达式……

CodeExpression 是所有表达式对象的公共基类，从它的派生类来看，咱们不妨对表达式的类型先来个非专业总结，这样有助于大家掌握思路。这个类的派生类相当多，不要晕，思路理清了，就不怕它数量多。

老周大致把这些表达式类划分以下几类（仅供参考）：

1、创建实例。如CodeArrayCreateExpression、CodeDelegateCreateExpression等，大家可以根据它们的名字来猜猜其作用，现在你不必弄明白到底怎么用，后面老周会教你怎么用的。

2、引用。比如当前实例引用（this）CodeThisReferenceExpression，再比如引用某个实例的方法的语句 CodeMethodReferenceExpression， 像 x.Run(……)。再比如属性里面set访问器中，大家都知道有一个 value 关键字，要引用它可以用 CodePropertySetValueReferenceExpression 类。

3、运算符（操作符）。这好懂了吧，+-*/=()==!<>这些都是操作符。对于二进制运算，可以用CodeBinaryOperatorExpression，它通过 CodeBinaryOperatorType 枚举来规范要用到的运算符，如加法、减法等。如果要进行类型转换，可以使用类型转换运算符 CodeCastExpression，它也是一种表达式。如果想用 typeof 运算符，可以使用 CodeTypeOfExpression 类。

4、其他。比较零碎。像参数引用，数组索引等。

很多表达式类在使用时，直接赋相应的值就行，用习惯了之后也不会很难。在举例之前，老周先讲一下如何生成代码，相信大伙在做完例子后，最迫切的就是想看看生成的代码是啥样子的。

生成代码要用 CodeDomProvider 类（位于System.CodeDom.Compiler命名空间下），这个类不用 new 的，它有一个静态的 CreateProvider 方法，调用后直接返回 CodeDomProvider 实例，调用方法时，可以用一个字符来指定编程语言。比如，C#、cs、CSharp都可以表示C#语言；用 VB、VisualBasic都表示VB语言；用js、JScript表示jscript语言；用cpp表示C++语言（托管）。名字是不区分大小写的，所以，CS和cs都一样。

然后，你会看到这个类有一堆GenerateCodeFromXXXX的方法，这些XXXX可以是表达式、语句、编译单元、类型定义等。生成代码时，你必须提供一个 TextWriter，代码生成后会写进这个writer里面。

下面给大家演示一下，咱们就把代码输出到控制台吧，这样马上就能看到效果。

假设我定义一个类型，名叫 Dog，它是结构。来，看代码：

            CodeTypeDeclaration dcl = new CodeTypeDeclaration("Dog");
            dcl.IsStruct = true;
            dcl.Attributes = MemberAttributes.Public;

IsStruct 指明它是个结构，CodeTypeDeclaration类构造函数中传的是类型的名字，叫Dog。Attributes属性设置这个类型为公共类型（public）。

好，现在我们就定义好一个类型了，下面咱们来生成C#、VB和C++三种语言的代码。

            // 生成C#代码
            CodeDomProvider provider = CodeDomProvider.CreateProvider("cs");
            Console.WriteLine("生成 C# 代码：");
            provider.GenerateCodeFromType(dcl, Console.Out, null);

            // 生成 VB 代码
            provider = CodeDomProvider.CreateProvider("vb");
            Console.WriteLine("/n生成 VB 代码：");
            provider.GenerateCodeFromType(dcl, Console.Out, null);

            // 生成 C++ 代码
            provider = CodeDomProvider.CreateProvider("cpp");
            Console.WriteLine("/n生成 C++ 代码：");
            provider.GenerateCodeFromType(dcl, Console.Out, null);

运行后，就会看到以下内容。

方法很简单，先用CreateProvider静态方法获取特定语言的提供程序，然后 GenerateCodeFromXXXXX，你要从什么代码对象生成，就调用哪个版本，比如要从编译单元生成代码，就应当调用GenerateCodeFromCompileUnit方法，要从定义的命名空间生成代码就调用GenerateCodeFromNamespace方法。

好，咱们开始练习，先来个操作符的，下面例子用来生成 a + b，a和b是变量名，我们先不管变量是哪来的，反正目的是使用操作符。

            CodeVariableReferenceExpression left = new CodeVariableReferenceExpression("a");
            CodeVariableReferenceExpression right = new CodeVariableReferenceExpression("b");
            CodeBinaryOperatorExpression opt = new CodeBinaryOperatorExpression();
            opt.Operator = CodeBinaryOperatorType.Add;
            opt.Left = left;
            opt.Right = right;

一个操作符表达式，通常会三个组成元素——运算符，左边操作数，右边操作数。在这个例子里面，左边和右边分别使用变量引用，即用到 CodeVariableReferenceExpression 类，这个类用法也简单，只要提供一个变量名称就行了。

最后生成代码为：

(a + b)

再看一个例子。

            CodeThisReferenceExpression thisexpr = new CodeThisReferenceExpression();
            CodeFieldReferenceExpression fexp = new CodeFieldReferenceExpression();
            fexp.FieldName = "m_val";
            fexp.TargetObject = thisexpr;

            CodeBinaryOperatorExpression opt = new CodeBinaryOperatorExpression();
            opt.Left = fexp;
            opt.Right = new CodePrimitiveExpression((int)300);
            opt.Operator = CodeBinaryOperatorType.Assign;

上面例子中的 CodeBinaryOperatorExpression 对象指定运算符为 Assign， 即赋值符号（=）。然后我们再看它两边的操作数。左边引用的是当前实例的字段，首先要创建一个CodeThisReferenceExpression，这个类不需要指定任何参数，因为它生成的就是this关键字，然后用CodeFieldReferenceExpression来引用this实例中一个叫m_val的字段；右边操作数是一个常量，常量值可以用CodePrimitiveExpression来表示。

CodePrimitiveExpression 一般用于指定基础类型的常量值，如int、string、double等。如这样

CodePrimitiveExpression p = new CodePrimitiveExpression(0.1322d);

生成代码后，会自动将传入的值表示为double类型常量。生成代码如下：

0.1322D

再比如

  CodePrimitiveExpression p = new CodePrimitiveExpression("ask");

就会生成字符串常量：

"ask"

好了，上面的赋值表达式最终得到的结果如下：

(this.m_val = 300)

下面咱们来生成一句 typeof表达式。

            CodeTypeOfExpression texp = new CodeTypeOfExpression(typeof(string));

            Console.WriteLine("C# 代码：");
            CodeDomProvider prd = CodeDomProvider.CreateProvider("cs");
            prd.GenerateCodeFromExpression(texp, Console.Out, null);

            Console.WriteLine("/n");
            Console.WriteLine("VB 代码：");
            CodeDomProvider prd2 = CodeDomProvider.CreateProvider("vb");
            prd2.GenerateCodeFromExpression(texp, Console.Out, null);

很简单，实例化 CodeTypeOfExpression 时，把某个类型的type传进去就行了。

最后输出的代码如下：

C# 代码：
typeof(string)

VB 代码：
GetType(String)

咱们再来个类型转换的表达式。

            CodeVariableReferenceExpression vexp = new CodeVariableReferenceExpression();
            vexp.VariableName = "x";
            CodeTypeReference tref = new CodeTypeReference(typeof(decimal));
            CodeCastExpression cexp = new CodeCastExpression();
            cexp.Expression = vexp;
            cexp.TargetType = tref;

CodeVariableReferenceExpression主要设置两个参数，Expression 指的是要进行类型转换的对象，通常是一个变量；TargetType是要转换的目标类型，需要用一个CodeTypeReference来封装，使用时直接把类型的type传递即可。

类型转换表达式生成代码如下：

((decimal)(x))

=================================================

学会使用表达式后，语句就好办了，因为语句就是由表达式组成的，只是为了说明是语句，在C类风格的语言中会以英文的分号结尾（VB除外）。

来，来一句赋值语句。

            CodeVariableReferenceExpression left = new CodeVariableReferenceExpression("f");
            CodePrimitiveExpression sexp = new CodePrimitiveExpression("so hot");
            CodeAssignStatement assstm = new CodeAssignStatement();
            assstm.Left = left;
            assstm.Right = sexp;

CodeAssignStatement 和刚才的赋值表达式很像，也需要指定左边的表达式和右边的表达式。最后生成的代码如下：

f = "so hot";

大家看到了，语句结尾是有分号的，刚才的表达式是没有分号的。

接下来，咱们声明一个变量，然后给它一个值。

            CodeVariableDeclarationStatement decl = new CodeVariableDeclarationStatement(typeof(int), "n");

            CodeAssignStatement ass = new CodeAssignStatement();
            ass.Left = new CodeVariableReferenceExpression("n");
            ass.Right = new CodePrimitiveExpression(98000);

            CodeDomProvider prd = CodeDomProvider.CreateProvider("cs");
            prd.GenerateCodeFromStatement(decl, Console.Out, null);
            prd.GenerateCodeFromStatement(ass, Console.Out, null);

这段实际上是生成了两句代码，第一句是声明语句，CodeVariableDeclarationStatement将产生声明变量的语句，需要指定变量的类型和变量名。

第二句是赋值语句，需要指定左边和右边。左边引用变量n，右边是常量值。

生成代码如下：

int n;
n = 98000;

以上代码不够简洁，我们完全可以在声明变量的时候，就将它初始化，这样只用一个语句就可以了。

CodeVariableDeclarationStatement decl = new CodeVariableDeclarationStatement(typeof(int), "n", new CodePrimitiveExpression(98000));

这样一个语句就完成了，生成的代码如下：

int n = 98000;

这里老周不会将所有语句一个个做介绍。本文介绍的这些表达式和语句，主要是帮助初学者朋友们练手，以便找到感觉，剩下的一些复杂的语句——如选择语句、循环语句这些，老周在后面的文章中会介绍的。

OK，今天的牛皮就吹到这里，希望对各位有帮助。