support else if

Author: chaowlert

ConsoleApp1/Program.cs

@@ -12,8 +12,7 @@ static void Main(string[] args)
             var p2 = Expression.Parameter(typeof(int));
             var body = Expression.Add(p1, p2);
             var lambda = Expression.Lambda<Func<int, int, int>>(body, p1, p2);
-            var filename = "test.cs";
-            var fun = lambda.Compile(filename);
+            var fun = lambda.CompileWithDebugInfo();
             var result = fun(1, 2);
             Console.WriteLine(3);
         }

ExpressionDebugger.Test/DebugInfoInjectorTest.cs

@@ -83,6 +83,35 @@ public void TestConditional_Block()
             , str);
         }
 
+        [TestMethod]
+        public void TestConditional_Block_Chain()
+        {
+            var exp = Expression.Condition(
+                Expression.Equal(Expression.Constant(1), Expression.Constant(2)),
+                Expression.Constant(4),
+                Expression.Condition(
+                    Expression.Equal(Expression.Constant(5), Expression.Constant(6)),
+                    Expression.Constant(3),
+                    Expression.Constant(2),
+                    typeof(void)),
+                typeof(void));
+            var str = exp.ToScript();
+            Assert.AreEqual(@"
+if (1 == 2)
+{
+    4;
+}
+else if (5 == 6)
+{
+    3;
+}
+else
+{
+    2;
+}"
+            , str);
+        }
+
         [TestMethod]
         public void TestConstant()
         {

ExpressionDebugger/DebugInfoInjector.cs

@@ -590,38 +590,50 @@ protected override CatchBlock VisitCatchBlock(CatchBlock node)
 
         Expression VisitConditional(ConditionalExpression node, bool shouldReturn)
         {
-            Expression test, ifTrue, ifFalse;
             if (IsInline(node))
             {
-                test = VisitGroup(node.Test, node.NodeType);
+                Expression test = VisitGroup(node.Test, node.NodeType);
                 Write(" ? ");
-                ifTrue = VisitGroup(node.IfTrue, node.NodeType);
+                Expression ifTrue = VisitGroup(node.IfTrue, node.NodeType);
                 Write(" : ");
-                ifFalse = VisitGroup(node.IfFalse, node.NodeType);
+                Expression ifFalse = VisitGroup(node.IfFalse, node.NodeType);
                 return node.Update(test, ifTrue, ifFalse);
             }
             else
             {
+                return VisitConditionalBlock(node, shouldReturn);
+            }
+        }
+
+        Expression VisitConditionalBlock(ConditionalExpression node, bool shouldReturn, bool chain = false)
+        {
+            if (chain)
+                WriteNextLine("else if (");
+            else
                 WriteNextLine("if (");
-                var position = GetPosition();
-                test = Visit(node.Test);
-                var debug = CreateDebugInfo(position);
-                Write(")");
-                Indent();
-                ifTrue = VisitBody(node.IfTrue, shouldReturn);
-                Outdent();
-                ifFalse = node.IfFalse;
-                if (node.Type == typeof(void) && node.IfFalse.NodeType != ExpressionType.Default)
+            var position = GetPosition();
+            Expression test = Visit(node.Test);
+            var debug = CreateDebugInfo(position);
+            Write(")");
+            Indent();
+            Expression ifTrue = VisitBody(node.IfTrue, shouldReturn);
+            Outdent();
+            Expression ifFalse = node.IfFalse;
+            if (node.Type == typeof(void) && node.IfFalse.NodeType != ExpressionType.Default)
+            {
+                if (node.IfFalse.NodeType == ExpressionType.Conditional)
+                    ifFalse = VisitConditionalBlock((ConditionalExpression)node.IfFalse, shouldReturn, true);
+                else
                 {
                     WriteNextLine("else");
                     Indent();
                     ifFalse = VisitBody(node.IfFalse, shouldReturn);
                     Outdent();
                 }
-                return Expression.Block(
-                    debug,
-                    Expression.Condition(test, ifTrue, ifFalse));
             }
+            return Expression.Block(
+                debug,
+                Expression.Condition(test, ifTrue, ifFalse));
         }
 
         protected override Expression VisitConditional(ConditionalExpression node)

ExpressionDebugger/ExpressionDebugger.csproj

@@ -4,7 +4,7 @@
     <TargetFrameworks>net40;net45;netstandard1.3</TargetFrameworks>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Authors>Chaowlert Chaisrichalermpol</Authors>
-    <Description>Step through debugging and generate readable script from linq expressions</Description>
+    <Description>Step into debugging and generate readable script from linq expressions</Description>
     <PackageProjectUrl>https://github.com/chaowlert/ExpressionDebugger</PackageProjectUrl>
     <RepositoryUrl>https://github.com/chaowlert/ExpressionDebugger</RepositoryUrl>
     <PackageTags>expression;linq;debug</PackageTags>

ExpressionDebugger/ExpressionExtensions.cs

@@ -1,27 +1,40 @@
-using System;
+using ExpressionDebugger;
 using System.Diagnostics;
 using System.IO;
-using System.Linq.Expressions;
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Runtime.CompilerServices;
 
-namespace ExpressionDebugger
+namespace System.Linq.Expressions
 {
     public static class ExpressionExtensions
     {
+        /// <summary>
+        /// Generate script text
+        /// </summary>
+        /// <param name="node">Expression</param>
+        /// <returns>Script text</returns>
         public static string ToScript(this Expression node)
         {
             var writer = new StringWriter();
             new DebugInfoInjector(writer).Inject(node);
             return writer.ToString();
         }
 
-        public static T Compile<T>(this Expression<T> node, string filename)
+        /// <summary>
+        /// Compile with debugging info injected
+        /// </summary>
+        /// <typeparam name="T">Type of lambda expression</typeparam>
+        /// <param name="node">Lambda expression</param>
+        /// <param name="filename">Filename to inject source code. if omit, temp filename will be used</param>
+        /// <returns>Generated method</returns>
+        public static T CompileWithDebugInfo<T>(this Expression<T> node, string filename = null)
         {
 #if NETSTANDARD1_3
             return node.Compile();
 #else
+            if (filename == null)
+                filename = Path.GetTempFileName();
             var name = "m_" + Guid.NewGuid().ToString("N");
             var asm = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.Run);