C#判断语句的表达式树实现

c# 提供了以下类型的判断语句：

语句	描述
if	一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
if...else	一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套 if 语句	您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
switch 语句	一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套 switch 语	您可以在一个 switch 语句内使用另一个 switch 语句。

当然还有 ??、?: 等判断，下面将详细实践。

if

if 语句，使用 ifthen(expression test, expression iftrue); 来表达

expression test表示用于判断的表达式，expression iftrue表示结果为 true 时执行的表达式树。

示例

            int a = 10;
            int b = 10;
            
            if (a == b)
            {
                console.writeline("a == b 为 true，语句被执行");
            }

            console.readkey();

使用表达式树实现如下

            parameterexpression a = expression.variable(typeof(int), "a");
            parameterexpression b = expression.variable(typeof(int), "b");
            methodcallexpression call = expression.call(
                null,
                typeof(console).getmethod("writeline", new type[] { typeof(string) }),
                expression.constant("a == b 为 true，表达式树被执行"));

            conditionalexpression _if = expression.ifthen(expression.equal(a, b),call);

            expression<action<int, int>> lambda = expression.lambda<action<int, int>>(_if,a,b);
            lambda.compile()(10,10);

            console.readkey();

生成的表达式树如下

.lambda #lambda1<system.action`2[system.int32,system.int32]>(
    system.int32 $a,
    system.int32 $b) {
    .if ($a == $b) {
        .call system.console.writeline("a == b 为 true，表达式树被执行")
    } .else {
        .default(system.void)
    }
}

if...else

if...else 使用以下表达式树表示

 conditionalexpression ifthenelse(expression test, expression iftrue, expression iffalse);

示例代码如下

            int a = 10;
            int b = 11;

            if (a == b)
            {
                console.writeline("a == b 为 true，此语句被执行");
            }
            else
            {
                console.writeline("a == b 为 false，此语句被执行");
            }
            console.readkey();

用表达式树实现如下

            parameterexpression a = expression.variable(typeof(int), "a");
            parameterexpression b = expression.variable(typeof(int), "b");
            methodcallexpression call1 = expression.call(
                null,
                typeof(console).getmethod("writeline", new type[] { typeof(string) }),
                expression.constant("a == b 为 true，此表达式树被执行"));

            methodcallexpression call2 = expression.call(
                null,
                typeof(console).getmethod("writeline", new type[] { typeof(string) }),
                expression.constant("a == b 为 false，此表达式树被执行"));

            conditionalexpression _if = expression.ifthenelse(expression.equal(a, b), call1,call2);

            expression<action<int, int>> lambda = expression.lambda<action<int, int>>(_if, a, b);
            lambda.compile()(10, 11);

            console.readkey();

生成的表达式树如下

.lambda #lambda1<system.action`2[system.int32,system.int32]>(
    system.int32 $a,
    system.int32 $b) {
    .if ($a == $b) {
        .call system.console.writeline("a == b 为 true，此表达式树被执行")
    } .else {
        .call system.console.writeline("a == b 为 false，此表达式树被执行")
    }
}

switch

示例代码如下

            int a = 2;
            switch (a)
            {
                case 1:console.writeline("a == 1");break;
                case 2:console.writeline("a == 2");break;
                default:console.writeline("a != 1 && a = 2");
            }

            console.readkey();

每个 case 使用 switchcase 类型表示，使用 expression.switchcase 生成 switchcase 类型。

expression.switch 用来构建一个 switch 表达式树，

expression.switch 的重载比较多，常用的是这种形式

switchexpression switch(expression switchvalue, expression defaultbody, params switchcase[] cases);

switchvalue 表示传入参数；

defaultbody 表示 default 执行的表达式；

cases 表示多条 case 。

上面代码对应使用表达式树编写如下

            parameterexpression a = expression.parameter(typeof(int), "a");
            methodcallexpression _default = expression.call(
                null,
                typeof(console).getmethod("writeline", new type[] { typeof(string) }),
                expression.constant("a != 1 && a = 2"));

            switchcase case1 = expression.switchcase(
                expression.call(null,
                typeof(console).getmethod("writeline", new type[] { typeof(string) }),
                expression.constant("a == 1")),
                new constantexpression[] { expression.constant(1) }
                );

            switchcase case2 = expression.switchcase(
                expression.call(null,
                typeof(console).getmethod("writeline", new type[] { typeof(string) }),
                expression.constant("a == 2")),
                new constantexpression[] { expression.constant(2) }
                );

            switchexpression _switch = expression.switch(a, _default, new switchcase[] { case1, case2 });
            expression<action<int>> lambda = expression.lambda<action<int>>(_switch, a);
            lambda.compile()(1);

            console.readkey();

生成的表达式树如下

.lambda #lambda1<system.action`1[system.int32]>(system.int32 $a) {
    .switch ($a) {
    .case (1):
            .call system.console.writeline("a == 1")
    .case (2):
            .call system.console.writeline("a == 2")
    .default:
            .call system.console.writeline("a != 1 && a = 2")
    }
}

很奇怪，没有 break，但是表达式树是正常的，并且运行没问题；

?? 和 ?:

?? 表示空合并运算符，例如 a ?? b，如果 a 不为 null，即返回 a，否则返回 b；

常用定义如下

binaryexpression coalesce(expression left, expression right)

这里就不再赘述。

?: 是三元运算符，例如 a > b ? a : b 。

常用定义如下

conditionalexpression condition(expression test, expression iftrue, expression iffalse)

可以参考上面的 if...else 表达式树，这里不再赘述。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。