added: Support for conditional And and Or

added: FEC.TryCompile<TDelegate>(..)
changed: Optimized FEC branching a bit

Author: dadhi

FastExpressionCompiler.v3.ncrunchsolution

@@ -0,0 +1,5 @@
+<SolutionConfiguration>
+  <Settings>
+    <SolutionConfigured>True</SolutionConfigured>
+  </Settings>
+</SolutionConfiguration>

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -21,13 +21,13 @@ private static Expression<Func<X>> GetHoistedExpr()
         public class Compile
         {
             [Benchmark]
-            public Func<X> Compile_()
+            public object Compile_()
             {
                 return _hoistedExpr.Compile();
             }
 
             [Benchmark]
-            public Func<X> CompileFast()
+            public object CompileFast()
             {
                 return ExpressionCompiler.Compile(_hoistedExpr);
             }
@@ -43,19 +43,19 @@ public class Invoke
             B bb = new B();
 
             [Benchmark(Baseline = true)]
-            public X Constructor()
+            public object Constructor()
             {
                 return new X(aa, bb);
             }
 
             [Benchmark]
-            public X CompiledLambda()
+            public object CompiledLambda()
             {
                 return _lambdaCompiled();
             }
 
             [Benchmark]
-            public X FastCompiledLambda()
+            public object FastCompiledLambda()
             {
                 return _lambdaCompiledFast();
             }

test/FastExpressionCompiler.Benchmarks/HoistedLambdaBenchmark.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Linq.Expressions;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes.Exporters;
+
+namespace FastExpressionCompiler.Benchmarks
+{
+    public class HoistedLambdaBenchmark_LogicalOps
+    {
+        private static Expression<Func<bool>> And_with_or()
+        {
+            var x = 1;
+            var s = "Test";
+            return () => x == 1 && (s.Contains("S") || s.Contains("s"));
+        }
+
+        private static readonly Expression<Func<bool>> _hoistedExpr = And_with_or();
+
+        [MarkdownExporter]
+        public class Compile
+        {
+            [Benchmark]
+            public object Compile_()
+            {
+                return _hoistedExpr.Compile();
+            }
+
+            [Benchmark]
+            public object CompileFast()
+            {
+                return ExpressionCompiler.Compile(_hoistedExpr);
+            }
+        }
+
+        [MarkdownExporter]
+        public class Invoke
+        {
+            private static readonly Func<bool> _lambdaCompiled = _hoistedExpr.Compile();
+            private static readonly Func<bool> _lambdaCompiledFast = ExpressionCompiler.Compile(_hoistedExpr);
+
+            [Benchmark]
+            public object CompiledLambda()
+            {
+                return _lambdaCompiled();
+            }
+
+            [Benchmark]
+            public object FastCompiledLambda()
+            {
+                return _lambdaCompiledFast();
+            }
+        }
+    }
+}

test/FastExpressionCompiler.Benchmarks/HoistedLambdaBenchmark_LogicalOps.cs

@@ -6,8 +6,6 @@ public class Program
     {
         public static void Main()
         {
-            BenchmarkRunner.Run<ExpressionVsDryExpression>();
-
             //BenchmarkRunner.Run<HoistedLambdaBenchmark.Compile>();
             //BenchmarkRunner.Run<HoistedLambdaBenchmark.Invoke>();
 
@@ -16,6 +14,11 @@ public static void Main()
 
             //BenchmarkRunner.Run<ManuallyComposedLambdaBenchmark.Compile>();
             //BenchmarkRunner.Run<ManuallyComposedLambdaBenchmark.Invoke>();
+
+            //BenchmarkRunner.Run<ExpressionVsDryExpression>();
+
+            BenchmarkRunner.Run<HoistedLambdaBenchmark_LogicalOps.Compile>();
+            //BenchmarkRunner.Run<HoistedLambdaBenchmark.Invoke>();
         }
     }
 }

test/FastExpressionCompiler.Benchmarks/Program.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Linq.Expressions;
+using NUnit.Framework;
+
+namespace FastExpressionCompiler.UnitTests
+{
+    [TestFixture]
+    public class LogicalOperatorsTests
+    {
+        private static Expression<Func<bool>> And()
+        {
+            var x = 1;
+            var s = "Test";
+            return () => x == 1 && s.Contains("S");
+        }
+
+        [Test]
+        public void Logical_and()
+        {
+            var expr = And();
+
+            var dlg = ExpressionCompiler.TryCompile<Func<bool>>(expr);
+
+            Assert.IsNotNull(dlg);
+            Assert.IsFalse(dlg());
+        }
+
+        private static Expression<Func<bool>> Or()
+        {
+            var x = 1;
+            var s = "Test";
+            return () => x == 0 || s.Contains("S");
+        }
+
+        [Test]
+        public void Logical_or()
+        {
+            var expr = Or();
+
+            var dele = ExpressionCompiler.TryCompile<Func<bool>>(expr);
+
+            Assert.IsNotNull(dele);
+        }
+
+        private static Expression<Func<bool>> And_with_or()
+        {
+            var x = 1;
+            var s = "Test";
+            return () => x == 1 && (s.Contains("S") || s.Contains("s"));
+        }
+
+        [Test]
+        public void Logical_and_with_or()
+        {
+            var expr = And_with_or();
+
+            var dele = ExpressionCompiler.TryCompile<Func<bool>>(expr);
+
+            Assert.IsNotNull(dele);
+        }
+    }
+}