AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

表达式树练习实践:C#循环与循环控制

2022-05-02 195
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 表达式树练习实践:C#循环与循环控制

C# 提供了以下几种循环类型。


循环类型 描述
while 循环 当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
for/foreach 循环 多次执行一个语句序列，简化管理循环变量的代码。
do...while 循环 除了它是在循环主体结尾测试条件外，其他与 while 语句类似。
嵌套循环 您可以在 while、for 或 do..while 循环内使用一个或多个循环。

当然，还有以下用于控制循环的语句

控制语句 描述
break 语句 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
continue 语句 引起循环跳过主体的剩余部分，立即重新开始测试条件。


LabelTarget

LabelTarget 是用于创建循环标记的。

无论是 for 还是 while ，平时编写循环时，都需要有跳出循环的判断，有时需要某个参数自增自减并且作为判断依据。


C# 表达式树里面是没有专门表示 for /while 的，里面只有一个 Loop。看一下Loop 生成的表达式树


.Lambda #Lambda1<System.Func`1[System.Int32]>() {
    .Block(System.Int32 $x) {
        $x = 0;
        .Loop  {
            .If ($x < 10) {
                $x++
            } .Else {
                .Break #Label1 { $x }
            }
        }
        .LabelTarget #Label1:
    }
}


要实现循环控制，有 break，contauine 两种 Expression：


public static GotoExpression Break(LabelTarget target, Type type);
        public static GotoExpression Break(LabelTarget target, Expression value);
        public static GotoExpression Break(LabelTarget target);
        public static GotoExpression Break(LabelTarget target, Expression value, Type type);


public static GotoExpression Continue(LabelTarget target, Type type);
        public static GotoExpression Continue(LabelTarget target);


所以，要实现循环控制，必须要使用 LabelTarget，不然就无限循环了。

要理解 LabelTarget ，最好的方法是动手做。


for / while 循环

Expression.Loop 用于创建循环，包括 for 和 while，定义如下


public static LoopExpression Loop(Expression body, LabelTarget @break, LabelTarget @continue);
      System.Linq.Expressions.LoopExpression.
        public static LoopExpression Loop(Expression body);
        public static LoopExpression Loop(Expression body, LabelTarget @break);


表达式树里面的循环，只有 Loop，无 for / while 的区别。

那么，我们来一步步理解 Loop 循环和 LabelTarget；


无限循环

while (true)
                {
                    Console.WriteLine("无限循环");
                }


那么，对应的 Loop 重载是这种


public static LoopExpression Loop(Expression body)


使用表达式树编写

BlockExpression _block = Expression.Block(
                new ParameterExpression[] { },
                Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }),Expression.Constant("无限循环") )
            );
            LoopExpression _loop = Expression.Loop(_block);
            Expression<Action> lambda = Expression.Lambda<Action>(_loop);
            lambda.Compile()();


最简单的循环

如果我想用表达式树做到如下最简单的循环，怎么写？


while (true)
            {
                Console.WriteLine("我被执行一次就结束循环了");
                break;
            }


表达式树编写

LabelTarget _break = Expression.Label();
            BlockExpression _block = Expression.Block(
               new ParameterExpression[] { },
               Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("我被执行一次就结束循环了")), Expression.Break(_break));
            LoopExpression _loop = Expression.Loop(_block, _break);
            Expression<Action> lambda = Expression.Lambda<Action>(_loop);
            lambda.Compile()();
            Console.ReadKey();


生成的表达式树

.Lambda #Lambda1<System.Action>() {
    .Loop  {
        .Block() {
            .Call System.Console.WriteLine("我被执行一次就结束循环了");
            .Break #Label1 { }
        }
    }
    .LabelTarget #Label1:
}


首先要明确，Expression.Label() 里面可以为空，它是一种标记，不参与传递参数，不参与运算。有参无参，前后保持一致即可。


但是上面的循环只有一次，你可以将上面的标签改成这样试试 LabelTarget _break = Expression.Label(typeof(int));，原因后面找。

还有， Expression.Label() 变量需要一致，否则无法跳出。


试试一下代码

BlockExpression _block = Expression.Block(
               new ParameterExpression[] { },
               Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("我被执行一次就结束循环了")), Expression.Break(Expression.Label()));
            LoopExpression _loop = Expression.Loop(_block, Expression.Label());
            Expression<Action> lambda = Expression.Lambda<Action>(_loop);
            lambda.Compile()();
            Console.ReadKey();


里面用到了 Expression.Block()，Block() 是块，即{}。

如果 Block() 是在最外层，那么相当于是函数；如果是内嵌，相当于{}；

但不是真的这样。。。表达式树里面不是完全按照 C# 的语法来还原操作的。

对于 Block() 的使用，多加实践即可。


多次循环

写一个循环十次的循环语句

for (int i = 0; i < 10; i++)
            {
                if (i < 10)
                {
                    Console.WriteLine(i);
                }
                else
                    break;
            }


或者使用 while 表示

int i = 0;
            while (true)
            {
                if (i < 10)
                {
                    Console.WriteLine(i);
                }
                else
                    break;
                i++;
            }


使用表达式树编写

LabelTarget _break = Expression.Label(typeof(int));
            ParameterExpression a = Expression.Variable(typeof(int), "a");
            BlockExpression _block = Expression.Block(new ParameterExpression[] { },
                Expression.IfThenElse
                (
                    Expression.LessThan(a, Expression.Constant(10)),
                    Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a),
                    Expression.Break(_break, a)
                ),
                Expression.PostIncrementAssign(a)   // a++
                );
            LoopExpression _loop = Expression.Loop(_block, _break);
            Expression<Action<int>> lambda = Expression.Lambda<Action<int>>(_loop, a);
            lambda.Compile()(0);
            Console.ReadKey();


生成的表达式树如下

.Lambda #Lambda1<System.Action`1[System.Int32]>(System.Int32 $a) {
    .Loop  {
        .Block() {
            .If ($a < 10) {
                .Call System.Console.WriteLine($a)
            } .Else {
                .Break #Label1 { $a }
            };
            $a++
        }
    }
    .LabelTarget #Label1:
}


试试将 Expression.Break(_break, a) 改成 Expression.Break(_break)。看看报什么错。。。

解决方法是，上面的标记也改成 LabelTarget _break = Expression.Label();。

就跟你写代码写注释一样，里面的东西是为了让别人看代码是容易理解。


有些同学纠结于 Expression.Label(有参或无参);，Expression.Break(_break, a) 与 Expression.Break(_break)，只要看看最终生成的表达式树就清楚了。


break 和 continue 一起

C# 循环代码如下

int i = 0;
            while (true)
            {
                if (i < 10)
                {
                    if (i % 2 == 0)
                    {
                        Console.Write("i是偶数:");
                        Console.WriteLine(i);
                        i++;
                        continue;
                    }
                    Console.WriteLine("其他任务 --");
                    Console.WriteLine("其他任务 --");
                }
                else break;
                i++;
            }


使用 C# 表达式树编写(笔者将步骤详细拆分了，所以代码比较长)

ParameterExpression a = Expression.Variable(typeof(int), "a");
            LabelTarget _break = Expression.Label();
            LabelTarget _continue = Expression.Label();
            //        if (i % 2 == 0)
            //        {
            //            Console.Write("i是偶数:");
            //            Console.WriteLine(i);
            //            i++;
            //            continue;
            //        }
            ConditionalExpression _if = Expression.IfThen(
                Expression.Equal(Expression.Modulo(a, Expression.Constant(2)), Expression.Constant(0)),
                Expression.Block(
                    new ParameterExpression[] { },
                    Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }), Expression.Constant("i是偶数:")),
                    Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a),
                    Expression.PostIncrementAssign(a),
                    Expression.Continue(_continue)
                    )
                );
            //        if (i % 2 == 0)
            //        {
            //            Console.Write("i是偶数:");
            //            Console.WriteLine(i);
            //            i++;
            //            continue;
            //        }
            //        Console.WriteLine("其他任务 --");
            //        Console.WriteLine("其他任务 --");
            BlockExpression block1 = Expression.Block(
                new ParameterExpression[] { },
                _if,
                Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("其他任务 --")),
                Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("其他任务 --"))
                );
            //    if (i < 10)
            //    {
            //        if (i % 2 == 0)
            //        {
            //            Console.Write("i是偶数:");
            //            Console.WriteLine(i);
            //            i++;
            //            continue;
            //        }
            //        Console.WriteLine("其他任务 --");
            //        Console.WriteLine("其他任务 --");
            //    }
            //    else break;
            ConditionalExpression if_else = Expression.IfThenElse(
               Expression.LessThan(a, Expression.Constant(10)),
                block1,
                Expression.Break(_break)
                );
            //    if (i < 10)
            //    {
            //        if (i % 2 == 0)
            //        {
            //            Console.Write("i是偶数:");
            //            Console.WriteLine(i);
            //            i++;
            //            continue;
            //        }
            //        Console.WriteLine("其他任务 --");
            //        Console.WriteLine("其他任务 --");
            //    }
            //    else break;
            //    i++ ;
            BlockExpression block2 = Expression.Block(
                new ParameterExpression[] { },
                if_else,
                Expression.PostIncrementAssign(a)
                );
            // while(true)
            LoopExpression loop = Expression.Loop(block2, _break, _continue);
            Expression<Action<int>> lambda = Expression.Lambda<Action<int>>(loop, a);
            lambda.Compile()(0);
            Console.ReadKey();


生成的表达式树如下

.Lambda #Lambda1<System.Action`1[System.Int32]>(System.Int32 $a) {
    .Loop .LabelTarget #Label1: {
        .Block() {
            .If ($a < 10) {
                .Block() {
                    .If (
                        $a % 2 == 0
                    ) {
                        .Block() {
                            .Call System.Console.Write("i是偶数:");
                            .Call System.Console.WriteLine($a);
                            $a++;
                            .Continue #Label1 { }
                        }
                    } .Else {
                        .Default(System.Void)
                    };
                    .Call System.Console.WriteLine("其他任务 --");
                    .Call System.Console.WriteLine("其他任务 --")
                }
            } .Else {
                .Break #Label2 { }
            };
            $a++
        }
    }
    .LabelTarget #Label2:
}


为了便于理解，上面的代码拆分了很多步。

来个简化版本

ParameterExpression a = Expression.Variable(typeof(int), "a");
            LabelTarget _break = Expression.Label();
            LabelTarget _continue = Expression.Label();
            LoopExpression loop = Expression.Loop(
                Expression.Block(
                    new ParameterExpression[] { },
                    Expression.IfThenElse(
                        Expression.LessThan(a, Expression.Constant(10)),
                        Expression.Block(
                            new ParameterExpression[] { },
                            Expression.IfThen(
                                Expression.Equal(Expression.Modulo(a, Expression.Constant(2)), Expression.Constant(0)),
                                Expression.Block(
                                    new ParameterExpression[] { },
                                    Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }), Expression.Constant("i是偶数:")),
                                    Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a),
                                    Expression.PostIncrementAssign(a),
                                    Expression.Continue(_continue)
                                    )
                                ),
                            Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("其他任务 --")),
                            Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("其他任务 --"))
                            ),
                        Expression.Break(_break)
                        ),
                    Expression.PostIncrementAssign(a)
                    ),
                _break,
                _continue
                );
            Expression<Action<int>> lambda = Expression.Lambda<Action<int>>(loop, a);
            lambda.Compile()(0);
            Console.ReadKey();


需要注意的是，Expression.BreakExpression.Continue 有所区别。

当标签实例化都是 Expression.Label() 时，

Expression.Break(label);
Expression.Continu(label);


区别在于 continu 只能用 Expression.Label()。

Break 可以这样

LabelTarget label = Expression.Label ( typeof ( int ) );
ParameterExpression a = Expression.Variable(typeof(int), "a");
Expression.Break ( label , a )
文章标签：
C#
关键词：
树C#
实践C#
表达式C#
树实践C#
痴者工良
目录
相关文章
陌陌谣
|
4月前
|
存储 算法 安全
如何控制上网行为——基于 C# 实现布隆过滤器算法的上网行为管控策略研究与实践解析
在数字化办公生态系统中，企业对员工网络行为的精细化管理已成为保障网络安全、提升组织效能的核心命题。如何在有效防范恶意网站访问、数据泄露风险的同时，避免过度管控对正常业务运作的负面影响，构成了企业网络安全领域的重要研究方向。在此背景下，数据结构与算法作为底层技术支撑，其重要性愈发凸显。本文将以布隆过滤器算法为研究对象，基于 C# 编程语言开展理论分析与工程实践，系统探讨该算法在企业上网行为管理中的应用范式。
陌陌谣
128 8
陌陌谣
|
27天前
|
存储 机器学习/深度学习 监控
公司监控软件有哪些？监测方案：基于布隆过滤器的 C# 异常行为检测实践探索
本文探讨了布隆过滤器在公司监控软件中的技术应用，介绍其原理、优势及C#实现代码，助力企业高效构建数据安全防护体系。
陌陌谣
43 0
陌陌谣
|
3月前
|
监控 算法 安全
公司电脑监控软件关键技术探析：C# 环形缓冲区算法的理论与实践
环形缓冲区（Ring Buffer）是企业信息安全管理中电脑监控系统设计的核心数据结构，适用于高并发、高速率与短时有效的多源异构数据处理场景。其通过固定大小的连续内存空间实现闭环存储，具备内存优化、操作高效、数据时效管理和并发支持等优势。文章以C#语言为例，展示了线程安全的环形缓冲区实现，并结合URL访问记录监控应用场景，分析了其在流量削峰、关键数据保护和高性能处理中的适配性。该结构在日志捕获和事件缓冲中表现出色，对提升监控系统效能具有重要价值。
陌陌谣
93 1
陌陌谣
|
4月前
|
存储 监控 算法
局域网上网记录监控的 C# 基数树算法高效检索方案研究
在企业网络管理与信息安全领域，局域网上网记录监控是维护网络安全、规范网络行为的关键举措。随着企业网络数据量呈指数级增长，如何高效存储和检索上网记录数据成为亟待解决的核心问题。基数树（Trie 树）作为一种独特的数据结构，凭借其在字符串处理方面的卓越性能，为局域网上网记录监控提供了创新的解决方案。本文将深入剖析基数树算法的原理，并通过 C# 语言实现的代码示例，阐述其在局域网上网记录监控场景中的具体应用。
陌陌谣
119 7
陌陌谣
|
4月前
|
存储 监控 算法
基于 C# 时间轮算法的控制局域网上网时间与实践应用
在数字化办公与教育环境中，局域网作为内部网络通信的核心基础设施，其精细化管理水平直接影响网络资源的合理配置与使用效能。对局域网用户上网时间的有效管控，已成为企业、教育机构等组织的重要管理需求。这一需求不仅旨在提升员工工作效率、规范学生网络使用行为，更是优化网络带宽资源分配的关键举措。时间轮算法作为一种经典的定时任务管理机制，在局域网用户上网时间管控场景中展现出显著的技术优势。本文将系统阐述时间轮算法的核心原理，并基于 C# 编程语言提供具体实现方案，以期深入剖析该算法在局域网管理中的应用逻辑与实践价值。
陌陌谣
95 5
代码掌控者
|
10月前
|
安全 编译器 程序员
C# 中 foreach 循环和 for 循环深度比较
为什么建议你多数情况下使用 foreach 进行遍历循环？看完你就明白了
代码掌控者
275 5
wljslmz
|
开发框架 安全 .NET
全面掌握C#中的类型转换：详解与实践
【8月更文挑战第20天】
wljslmz
392 0
长梦
|
11月前
|
测试技术 C# 数据库
C# 一分钟浅谈：测试驱动开发 (TDD) 实践
【10月更文挑战第18天】测试驱动开发（TDD）是一种软件开发方法论，强调先编写测试代码再编写功能代码，以确保代码质量和可维护性。本文从 TDD 的基本概念入手，详细介绍了其核心步骤——编写测试、运行测试并失败、编写代码使测试通过，以及“红绿重构”循环。文章还探讨了 TDD 的优势，包括提高代码质量、促进设计思考、减少调试时间和文档化。此外，文中分析了常见问题及解决方案，如测试覆盖率不足、测试代码过于复杂、忽视重构和测试依赖过多，并通过一个简单的计算器类的代码案例，展示了 TDD 的实际应用过程。
长梦
186 1
何雨晨
|
11月前
|
Java C#
如何避免在C#循环中使用await
如何避免在C#循环中使用await
何雨晨
289 9
长梦
|
11月前
|
存储 JSON API
HTTP 请求与响应处理：C#中的实践
【10月更文挑战第4天】在现代Web开发中，HTTP协议至关重要，无论构建Web应用还是API开发，都需要熟练掌握HTTP请求与响应处理。本文从C#角度出发，介绍HTTP基础知识，包括请求与响应结构，并通过`HttpClient`库演示如何发送GET请求及处理响应，同时分析常见错误并提供解决方案，助你更高效地完成HTTP相关任务。
长梦
338 2