Added EvaluateOptions.CaseInsensitiveComparer

src/NCalcAsync/Domain/EvaluationVisitor.cs

@@ -8,14 +8,14 @@ namespace NCalcAsync.Domain
 {
     public class EvaluationVisitor : LogicalExpressionVisitor
     {
-        private delegate T Func<T>();
+        private delegate T Func<out T>();
 
-        private readonly EvaluateOptions _options = EvaluateOptions.None;
+        private readonly EvaluateOptions _options;
         private readonly EvaluateParameterAsyncHandler _evaluateParameterAsync;
         private readonly EvaluateFunctionAsyncHandler _evaluateFunctionAsync;
         private readonly NumberConversionTypePreference _numberConversionTypePreference;
 
-        private bool IgnoreCase { get { return (_options & EvaluateOptions.IgnoreCase) == EvaluateOptions.IgnoreCase; } }
+        private bool IgnoreCase => (_options & EvaluateOptions.IgnoreCase) == EvaluateOptions.IgnoreCase;
 
         public EvaluationVisitor(EvaluateOptions options, EvaluateParameterAsyncHandler evaluateParameterAsync, EvaluateFunctionAsyncHandler evaluateFunctionAsync, NumberConversionTypePreference numberConversionTypePreference = NumberConversionTypePreference.Decimal)
         {
@@ -38,7 +38,7 @@ public override Task VisitAsync(LogicalExpression expression)
             return Task.FromException(new Exception("The method or operation is not implemented."));
         }
 
-        private static Type[] CommonTypes = new[] { typeof(Int64), typeof(Double), typeof(Boolean), typeof(String), typeof(Decimal) };
+        private static readonly Type[] CommonTypes = { typeof(Int64), typeof(Double), typeof(Boolean), typeof(String), typeof(Decimal) };
 
         /// <summary>
         /// Gets the the most precise type.
@@ -73,7 +73,11 @@ public int CompareUsingMostPreciseType(object a, object b)
                 mpt = GetMostPreciseType(a.GetType(), b?.GetType());
             }
 
-            return Comparer.Default.Compare(Convert.ChangeType(a, mpt), Convert.ChangeType(b, mpt));
+            bool isCaseSensitiveComparer = (_options & EvaluateOptions.CaseInsensitiveComparer) == 0;
+
+            var comparer = isCaseSensitiveComparer ? (IComparer)Comparer.Default : CaseInsensitiveComparer.Default;
+
+            return comparer.Compare(Convert.ChangeType(a, mpt), Convert.ChangeType(b, mpt));
         }
 
         public override async Task VisitAsync(TernaryExpression expression)

src/NCalcAsync/EvaluationOption.cs

@@ -25,6 +25,11 @@ public enum EvaluateOptions
         //
         // Summary:
         //     When using Round(), if a number is halfway between two others, it is rounded toward the nearest number that is away from zero. 
-        RoundAwayFromZero = 16
+        RoundAwayFromZero = 16,
+
+        //
+        // Summary:
+        //     Specifies the use of CaseInsensitiveComparer for comparasions.
+        CaseInsensitiveComparer = 32
     }
 }

test/NCalcAsync.Tests/Fixtures.cs

@@ -854,6 +854,16 @@ public async Task Should_Do_Number_Conversion()
                 Assert.AreEqual(calculatedValue, await expression.EvaluateAsync());
             }
         }
+
+
+        [TestMethod]
+        public async Task Should_Use_Case_Insensitive_Comparer_Issue_24()
+        {
+            var eif = new Expression("PageState == 'LIST'", EvaluateOptions.CaseInsensitiveComparer);
+            eif.Parameters["PageState"] = "List";
+
+            Assert.AreEqual(true, await eif.EvaluateAsync());
+        }
     }
 }