From 048e90ba7ec9b9b637cc7004f857569408677405 Mon Sep 17 00:00:00 2001
From: jkuehner <jochen.kuehner@kardex.com>
Date: Tue, 17 Apr 2018 21:05:18 +0200
Subject: [PATCH 1/2] Support ParsingConfig in all Extension Methods which
 parse a String

---
 .../DynamicQueryableExtensions.cs             | 353 ++++++++++++++----
 .../ExpressionTests.cs                        |  25 ++
 2 files changed, 313 insertions(+), 65 deletions(-)

diff --git a/src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs b/src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs
index 3e617426..d8dbd155 100644
--- a/src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs
+++ b/src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs
@@ -357,25 +357,36 @@ public static dynamic First([NotNull] this IQueryable source)
         /// Returns the first element of a sequence that satisfies a specified condition.
         /// </summary>
         /// <param name="source">The <see cref="IQueryable"/> to return the first element of.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>The first element in source that passes the test in predicate.</returns>
         [PublicAPI]
 #if NET35
-        public static object First([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static object First([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #else
-        public static dynamic First([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static dynamic First([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #endif
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(predicate, nameof(predicate));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, predicate, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, predicate, args);
 
             return Execute(_firstPredicate, source, lambda);
         }
 
+        /// <inheritdoc cref="First(IQueryable, ParsingConfig, string, object[])"/>
+#if NET35
+        public static object First([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#else
+        public static dynamic First([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#endif
+        {
+            return First(source, null, predicate, args);
+        }
+
         /// <summary>
         /// Returns the first element of a sequence that satisfies a specified condition.
         /// </summary>
@@ -416,25 +427,36 @@ public static dynamic FirstOrDefault([NotNull] this IQueryable source)
         /// Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.
         /// </summary>
         /// <param name="source">The <see cref="IQueryable"/> to return the first element of.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>default if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.</returns>
         [PublicAPI]
 #if NET35
-        public static object FirstOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static object FirstOrDefault([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #else
-        public static dynamic FirstOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static dynamic FirstOrDefault([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #endif
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(predicate, nameof(predicate));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, predicate, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, predicate, args);
 
             return Execute(_firstOrDefaultPredicate, source, lambda);
         }
 
+        /// <inheritdoc cref="FirstOrDefault(IQueryable, ParsingConfig, string, object[])"/>
+#if NET35
+        public static object FirstOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#else
+        public static dynamic FirstOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#endif
+        {
+            return FirstOrDefault(source, null, predicate, args);
+        }
+
         /// <summary>
         /// Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.
         /// </summary>
@@ -460,6 +482,7 @@ public static dynamic FirstOrDefault([NotNull] this IQueryable source, [NotNull]
         /// and creates a result value from each group and its key.
         /// </summary>
         /// <param name="source">A <see cref="IQueryable"/> whose elements to group.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="keySelector">A string expression to specify the key for each element.</param>
         /// <param name="resultSelector">A string expression to specify a result value from each group.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters.  Similar to the way String.Format formats strings.</param>
@@ -471,15 +494,15 @@ public static dynamic FirstOrDefault([NotNull] this IQueryable source, [NotNull]
         /// </code>
         /// </example>
         [PublicAPI]
-        public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] string keySelector, [NotNull] string resultSelector, object[] args)
+        public static IQueryable GroupBy([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string keySelector, [NotNull] string resultSelector, object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(keySelector, nameof(keySelector));
             Check.NotEmpty(resultSelector, nameof(resultSelector));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression keyLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, keySelector, args);
-            LambdaExpression elementLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, resultSelector, args);
+            LambdaExpression keyLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, keySelector, args);
+            LambdaExpression elementLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, resultSelector, args);
 
             var optimized = OptimizeExpression(Expression.Call(
                 typeof(Queryable), nameof(Queryable.GroupBy),
@@ -489,11 +512,19 @@ public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] str
             return source.Provider.CreateQuery(optimized);
         }
 
+        /// <inheritdoc cref="GroupBy(IQueryable, ParsingConfig, string, string, object[])"/>
+        [PublicAPI]
+        public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] string keySelector, [NotNull] string resultSelector, object[] args)
+        {
+            return GroupBy(source, null, keySelector, resultSelector, args);
+        }
+
         /// <summary>
         /// Groups the elements of a sequence according to a specified key string function 
         /// and creates a result value from each group and its key.
         /// </summary>
         /// <param name="source">A <see cref="IQueryable"/> whose elements to group.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="keySelector">A string expression to specify the key for each element.</param>
         /// <param name="resultSelector">A string expression to specify a result value from each group.</param>
         /// <returns>A <see cref="IQueryable"/> where each element represents a projection over a group and its key.</returns>
@@ -503,13 +534,19 @@ public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] str
         /// var groupResult2 = queryable.GroupBy("new (NumberPropertyAsKey, StringPropertyAsKey)", "new (StringProperty1, StringProperty2)");
         /// </code>
         /// </example>
-        public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] string keySelector, [NotNull] string resultSelector)
+        public static IQueryable GroupBy([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string keySelector, [NotNull] string resultSelector)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(keySelector, nameof(keySelector));
             Check.NotEmpty(resultSelector, nameof(resultSelector));
 
-            return GroupBy(source, keySelector, resultSelector, null);
+            return GroupBy(source, config, keySelector, resultSelector, null);
+        }
+
+        /// <inheritdoc cref="GroupBy(IQueryable, ParsingConfig, string, string)"/>
+        public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] string keySelector, [NotNull] string resultSelector)
+        {
+            return GroupBy(source, null, keySelector, resultSelector);
         }
 
         /// <summary>
@@ -517,6 +554,7 @@ public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] str
         /// and creates a result value from each group and its key.
         /// </summary>
         /// <param name="source">A <see cref="IQueryable"/> whose elements to group.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="keySelector">A string expression to specify the key for each element.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>A <see cref="IQueryable"/> where each element represents a projection over a group and its key.</returns>
@@ -527,13 +565,13 @@ public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] str
         /// </code>
         /// </example>
         [PublicAPI]
-        public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] string keySelector, [CanBeNull] params object[] args)
+        public static IQueryable GroupBy([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string keySelector, [CanBeNull] params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(keySelector, nameof(keySelector));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression keyLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, keySelector, args);
+            LambdaExpression keyLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, keySelector, args);
 
             var optimized = OptimizeExpression(Expression.Call(
                 typeof(Queryable), nameof(Queryable.GroupBy),
@@ -541,6 +579,14 @@ public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] str
 
             return source.Provider.CreateQuery(optimized);
         }
+
+        /// <inheritdoc cref="GroupBy(IQueryable, ParsingConfig, string, object[])"/>
+        [PublicAPI]
+        public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] string keySelector, [CanBeNull] params object[] args)
+        {
+            return GroupBy(source, (ParsingConfig)null, keySelector, args);
+        }
+
         #endregion GroupBy
 
         #region GroupByMany
@@ -550,9 +596,10 @@ public static IQueryable GroupBy([NotNull] this IQueryable source, [NotNull] str
         /// </summary>
         /// <typeparam name="TElement"></typeparam>
         /// <param name="source">A <see cref="IEnumerable{T}"/> whose elements to group.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="keySelectors"><see cref="string"/> expressions to specify the keys for each element.</param>
         /// <returns>A <see cref="IEnumerable{T}"/> of type <see cref="GroupResult"/> where each element represents a projection over a group, its key, and its subgroups.</returns>
-        public static IEnumerable<GroupResult> GroupByMany<TElement>([NotNull] this IEnumerable<TElement> source, params string[] keySelectors)
+        public static IEnumerable<GroupResult> GroupByMany<TElement>([NotNull] this IEnumerable<TElement> source, [CanBeNull] ParsingConfig config, params string[] keySelectors)
         {
             Check.NotNull(source, nameof(source));
             Check.HasNoNulls(keySelectors, nameof(keySelectors));
@@ -562,13 +609,19 @@ public static IEnumerable<GroupResult> GroupByMany<TElement>([NotNull] this IEnu
             bool createParameterCtor = true;
             foreach (var selector in keySelectors)
             {
-                LambdaExpression l = DynamicExpressionParser.ParseLambda(createParameterCtor, typeof(TElement), typeof(object), selector);
+                LambdaExpression l = DynamicExpressionParser.ParseLambda(config, createParameterCtor, typeof(TElement), typeof(object), selector);
                 selectors.Add((Func<TElement, object>)l.Compile());
             }
 
             return GroupByManyInternal(source, selectors.ToArray(), 0);
         }
 
+        /// <inheritdoc cref="GroupByMany(IEnumerable{TElement}, ParsingConfig, string[])"/>
+        public static IEnumerable<GroupResult> GroupByMany<TElement>([NotNull] this IEnumerable<TElement> source, params string[] keySelectors)
+        {
+            return GroupByMany<TElement>(source, null, keySelectors);
+        }
+
         /// <summary>
         /// Groups the elements of a sequence according to multiple specified key functions 
         /// and creates a result value from each group (and subgroups) and its key.
@@ -609,13 +662,14 @@ static IEnumerable<GroupResult> GroupByManyInternal<TElement>(IEnumerable<TEleme
         /// Correlates the elements of two sequences based on equality of keys and groups the results. The default equality comparer is used to compare keys.
         /// </summary>
         /// <param name="outer">The first sequence to join.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="inner">The sequence to join to the first sequence.</param>
         /// <param name="outerKeySelector">A dynamic function to extract the join key from each element of the first sequence.</param>
         /// <param name="innerKeySelector">A dynamic function to extract the join key from each element of the second sequence.</param>
         /// <param name="resultSelector">A dynamic function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicates as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>An <see cref="IQueryable"/> obtained by performing a grouped join on two sequences.</returns>
-        public static IQueryable GroupJoin([NotNull] this IQueryable outer, [NotNull] IEnumerable inner, [NotNull] string outerKeySelector, [NotNull] string innerKeySelector, [NotNull] string resultSelector, params object[] args)
+        public static IQueryable GroupJoin([NotNull] this IQueryable outer, [CanBeNull] ParsingConfig config, [NotNull] IEnumerable inner, [NotNull] string outerKeySelector, [NotNull] string innerKeySelector, [NotNull] string resultSelector, params object[] args)
         {
             Check.NotNull(outer, nameof(outer));
             Check.NotNull(inner, nameof(inner));
@@ -627,8 +681,8 @@ public static IQueryable GroupJoin([NotNull] this IQueryable outer, [NotNull] IE
             Type innerType = inner.AsQueryable().ElementType;
 
             bool createParameterCtor = outer.IsLinqToObjects();
-            LambdaExpression outerSelectorLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, outerType, null, outerKeySelector, args);
-            LambdaExpression innerSelectorLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, innerType, null, innerKeySelector, args);
+            LambdaExpression outerSelectorLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, outerType, null, outerKeySelector, args);
+            LambdaExpression innerSelectorLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, innerType, null, innerKeySelector, args);
 
             CheckOuterAndInnerTypes(createParameterCtor, outerType, innerType, outerKeySelector, innerKeySelector, ref outerSelectorLambda, ref innerSelectorLambda, args);
 
@@ -638,7 +692,7 @@ public static IQueryable GroupJoin([NotNull] this IQueryable outer, [NotNull] IE
                 ParameterExpressionHelper.CreateParameterExpression(typeof(IEnumerable<>).MakeGenericType(innerType), "inner")
             };
 
-            LambdaExpression resultSelectorLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, parameters, null, resultSelector, args);
+            LambdaExpression resultSelectorLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, parameters, null, resultSelector, args);
 
             return outer.Provider.CreateQuery(Expression.Call(
                 typeof(Queryable), nameof(Queryable.GroupJoin),
@@ -649,6 +703,13 @@ public static IQueryable GroupJoin([NotNull] this IQueryable outer, [NotNull] IE
                 Expression.Quote(innerSelectorLambda),
                 Expression.Quote(resultSelectorLambda)));
         }
+
+        /// <inheritdoc cref="GroupJoin(IQueryable, IEnumerable, string, string, string, object[])"/>
+        public static IQueryable GroupJoin([NotNull] this IQueryable outer, [NotNull] IEnumerable inner, [NotNull] string outerKeySelector, [NotNull] string innerKeySelector, [NotNull] string resultSelector, params object[] args)
+        {
+            return GroupJoin(outer, null, inner, outerKeySelector, innerKeySelector, resultSelector, args);
+        }
+
         #endregion
 
         #region Join
@@ -656,13 +717,14 @@ public static IQueryable GroupJoin([NotNull] this IQueryable outer, [NotNull] IE
         /// Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.
         /// </summary>
         /// <param name="outer">The first sequence to join.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="inner">The sequence to join to the first sequence.</param>
         /// <param name="outerKeySelector">A dynamic function to extract the join key from each element of the first sequence.</param>
         /// <param name="innerKeySelector">A dynamic function to extract the join key from each element of the second sequence.</param>
         /// <param name="resultSelector">A dynamic function to create a result element from two matching elements.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicates as parameters.  Similar to the way String.Format formats strings.</param>
         /// <returns>An <see cref="IQueryable"/> obtained by performing an inner join on two sequences.</returns>
-        public static IQueryable Join([NotNull] this IQueryable outer, [NotNull] IEnumerable inner, [NotNull] string outerKeySelector, [NotNull] string innerKeySelector, [NotNull] string resultSelector, params object[] args)
+        public static IQueryable Join([NotNull] this IQueryable outer, [CanBeNull] ParsingConfig config, [NotNull] IEnumerable inner, [NotNull] string outerKeySelector, [NotNull] string innerKeySelector, [NotNull] string resultSelector, params object[] args)
         {
             //http://stackoverflow.com/questions/389094/how-to-create-a-dynamic-linq-join-extension-method
 
@@ -676,8 +738,8 @@ public static IQueryable Join([NotNull] this IQueryable outer, [NotNull] IEnumer
             Type innerType = inner.AsQueryable().ElementType;
 
             bool createParameterCtor = outer.IsLinqToObjects();
-            LambdaExpression outerSelectorLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, outerType, null, outerKeySelector, args);
-            LambdaExpression innerSelectorLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, innerType, null, innerKeySelector, args);
+            LambdaExpression outerSelectorLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, outerType, null, outerKeySelector, args);
+            LambdaExpression innerSelectorLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, innerType, null, innerKeySelector, args);
 
             CheckOuterAndInnerTypes(createParameterCtor, outerType, innerType, outerKeySelector, innerKeySelector, ref outerSelectorLambda, ref innerSelectorLambda, args);
 
@@ -687,7 +749,7 @@ public static IQueryable Join([NotNull] this IQueryable outer, [NotNull] IEnumer
                 ParameterExpressionHelper.CreateParameterExpression(innerType, "inner")
             };
 
-            LambdaExpression resultSelectorLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, parameters, null, resultSelector, args);
+            LambdaExpression resultSelectorLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, parameters, null, resultSelector, args);
 
             var optimized = OptimizeExpression(Expression.Call(
                 typeof(Queryable), "Join",
@@ -702,11 +764,18 @@ public static IQueryable Join([NotNull] this IQueryable outer, [NotNull] IEnumer
             return outer.Provider.CreateQuery(optimized);
         }
 
+        /// <inheritdoc cref="Join(IQueryable, ParsingConfig, IEnumerable, string, string, string, object[])"/>
+        public static IQueryable Join([NotNull] this IQueryable outer, [NotNull] IEnumerable inner, [NotNull] string outerKeySelector, [NotNull] string innerKeySelector, [NotNull] string resultSelector, params object[] args)
+        {
+            return Join(outer, null, inner, outerKeySelector, innerKeySelector, resultSelector, args);
+        }
+
         /// <summary>
         /// Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.
         /// </summary>
         /// <typeparam name="TElement">The type of the elements of both sequences, and the result.</typeparam>
         /// <param name="outer">The first sequence to join.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="inner">The sequence to join to the first sequence.</param>
         /// <param name="outerKeySelector">A dynamic function to extract the join key from each element of the first sequence.</param>
         /// <param name="innerKeySelector">A dynamic function to extract the join key from each element of the second sequence.</param>
@@ -714,10 +783,17 @@ public static IQueryable Join([NotNull] this IQueryable outer, [NotNull] IEnumer
         /// <param name="args">An object array that contains zero or more objects to insert into the predicates as parameters.  Similar to the way String.Format formats strings.</param>
         /// <remarks>This overload only works on elements where both sequences and the resulting element match.</remarks>
         /// <returns>An <see cref="IQueryable{T}"/> that has elements of type TResult obtained by performing an inner join on two sequences.</returns>
+        public static IQueryable<TElement> Join<TElement>([NotNull] this IQueryable<TElement> outer, [CanBeNull] ParsingConfig config, [NotNull] IEnumerable<TElement> inner, [NotNull] string outerKeySelector, [NotNull] string innerKeySelector, string resultSelector, params object[] args)
+        {
+            return (IQueryable<TElement>)Join((IQueryable)outer, config, (IEnumerable)inner, outerKeySelector, innerKeySelector, resultSelector, args);
+        }
+
+        /// <inheritdoc cref="Join(IQueryable, ParsingConfig, IEnumerable{TElement}, string, string, string, object[])"/>
         public static IQueryable<TElement> Join<TElement>([NotNull] this IQueryable<TElement> outer, [NotNull] IEnumerable<TElement> inner, [NotNull] string outerKeySelector, [NotNull] string innerKeySelector, string resultSelector, params object[] args)
         {
-            return (IQueryable<TElement>)Join((IQueryable)outer, (IEnumerable)inner, outerKeySelector, innerKeySelector, resultSelector, args);
+            return Join(outer, null, inner, outerKeySelector, innerKeySelector, resultSelector, args);
         }
+
         #endregion Join
 
         #region Last
@@ -744,24 +820,36 @@ public static dynamic Last([NotNull] this IQueryable source)
         /// Returns the last element of a sequence that satisfies a specified condition.
         /// </summary>
         /// <param name="source">The <see cref="IQueryable"/> to return the last element of.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>The first element in source that passes the test in predicate.</returns>
 #if NET35
-        public static object Last([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static object Last([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #else
-        public static dynamic Last([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static dynamic Last([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #endif
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(predicate, nameof(predicate));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, predicate, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, predicate, args);
 
             return Execute(_lastPredicate, source, lambda);
         }
 
+        /// <inheritdoc cref="Last(IQueryable, ParsingConfig, string, object[])"/>
+#if NET35
+        public static object Last([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#else
+        public static dynamic Last([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#endif
+        {
+            return Last(source, null, predicate, args);
+        }
+
+
         /// <summary>
         /// Returns the last element of a sequence that satisfies a specified condition.
         /// </summary>
@@ -803,24 +891,35 @@ public static dynamic LastOrDefault([NotNull] this IQueryable source)
         /// Returns the last element of a sequence that satisfies a specified condition, or a default value if the sequence contains no elements.
         /// </summary>
         /// <param name="source">The <see cref="IQueryable"/> to return the last element of.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>The first element in source that passes the test in predicate.</returns>
 #if NET35
-        public static object LastOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static object LastOrDefault([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #else
-        public static dynamic LastOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static dynamic LastOrDefault([NotNull] this IQueryable source,  [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #endif
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(predicate, nameof(predicate));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, predicate, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, predicate, args);
 
             return Execute(_lastDefaultPredicate, source, lambda);
         }
 
+        /// <inheritdoc cref="LastOrDefault(IQueryable, ParsingConfig, string, object[])"/>
+#if NET35
+        public static object LastOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#else
+        public static dynamic LastOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#endif
+        {
+            return LastOrDefault(source, null, predicate, args);
+        }
+
         /// <summary>
         /// Returns the last element of a sequence that satisfies a specified condition, or a default value if the sequence contains no elements.
         /// </summary>
@@ -844,6 +943,7 @@ public static dynamic LastOrDefault([NotNull] this IQueryable source, [NotNull]
         /// </summary>
         /// <typeparam name="TSource">The type of the elements of source.</typeparam>
         /// <param name="source">A sequence of values to order.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="ordering">An expression string to indicate values to order by.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>A <see cref="IQueryable{T}"/> whose elements are sorted according to the specified <paramref name="ordering"/>.</returns>
@@ -856,15 +956,22 @@ public static dynamic LastOrDefault([NotNull] this IQueryable source, [NotNull]
         /// ]]>
         /// </code>
         /// </example>
-        public static IOrderedQueryable<TSource> OrderBy<TSource>([NotNull] this IQueryable<TSource> source, [NotNull] string ordering, params object[] args)
+        public static IOrderedQueryable<TSource> OrderBy<TSource>([NotNull] this IQueryable<TSource> source, [CanBeNull] ParsingConfig config, [NotNull] string ordering, params object[] args)
         {
             return (IOrderedQueryable<TSource>)OrderBy((IQueryable)source, ordering, args);
         }
 
+        /// <inheritdoc cref="OrderBy(IQueryable{TSource}, ParsingConfig, string, object[])"/>
+        public static IOrderedQueryable<TSource> OrderBy<TSource>([NotNull] this IQueryable<TSource> source, [NotNull] string ordering, params object[] args)
+        {
+            return OrderBy(source, (ParsingConfig)null, ordering, args);
+        }
+
         /// <summary>
         /// Sorts the elements of a sequence in ascending or descending order according to a key.
         /// </summary>
         /// <param name="source">A sequence of values to order.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="ordering">An expression string to indicate values to order by.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters.  Similar to the way String.Format formats strings.</param>
         /// <returns>A <see cref="IQueryable"/> whose elements are sorted according to the specified <paramref name="ordering"/>.</returns>
@@ -875,13 +982,13 @@ public static IOrderedQueryable<TSource> OrderBy<TSource>([NotNull] this IQuerya
         /// var resultMultiple = queryable.OrderBy("NumberProperty, StringProperty DESC");
         /// </code>
         /// </example>
-        public static IOrderedQueryable OrderBy([NotNull] this IQueryable source, [NotNull] string ordering, params object[] args)
+        public static IOrderedQueryable OrderBy([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string ordering, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(ordering, nameof(ordering));
 
             ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(source.ElementType, string.Empty) };
-            ExpressionParser parser = new ExpressionParser(parameters, ordering, args, null);
+            ExpressionParser parser = new ExpressionParser(parameters, ordering, args, config);
             IList<DynamicOrdering> dynamicOrderings = parser.ParseOrdering();
 
             Expression queryExpr = source.Expression;
@@ -897,6 +1004,13 @@ public static IOrderedQueryable OrderBy([NotNull] this IQueryable source, [NotNu
             var optimized = OptimizeExpression(queryExpr);
             return (IOrderedQueryable)source.Provider.CreateQuery(optimized);
         }
+
+        /// <inheritdoc cref="OrderBy(IQueryable, ParsingConfig, string, object[])"/>
+        public static IOrderedQueryable OrderBy([NotNull] this IQueryable source, [NotNull] string ordering, params object[] args)
+        {
+            return OrderBy(source, null, ordering, args);
+        }
+
         #endregion OrderBy
 
         #region Page/PageResult
@@ -1006,6 +1120,7 @@ public static IQueryable Reverse([NotNull] this IQueryable source)
         /// Projects each element of a sequence into a new form.
         /// </summary>
         /// <param name="source">A sequence of values to project.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="selector">A projection string expression to apply to each element.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters.  Similar to the way String.Format formats strings.</param>
         /// <returns>An <see cref="IQueryable"/> whose elements are the result of invoking a projection string on each element of source.</returns>
@@ -1015,13 +1130,13 @@ public static IQueryable Reverse([NotNull] this IQueryable source)
         /// var dynamicObject = queryable.Select("new (StringProperty1, StringProperty2 as OtherStringPropertyName)");
         /// </code>
         /// </example>
-        public static IQueryable Select([NotNull] this IQueryable source, [NotNull] string selector, params object[] args)
+        public static IQueryable Select([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string selector, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(selector, nameof(selector));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, selector, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, selector, args);
 
             var optimized = OptimizeExpression(Expression.Call(
                 typeof(Queryable), nameof(Queryable.Select),
@@ -1032,12 +1147,19 @@ public static IQueryable Select([NotNull] this IQueryable source, [NotNull] stri
             return source.Provider.CreateQuery(optimized);
         }
 
+        /// <inheritdoc cref="Select(IQueryable, ParsingConfig, string, object[])"/>
+        public static IQueryable Select([NotNull] this IQueryable source, [NotNull] string selector, params object[] args)
+        {
+            return Select(source, (ParsingConfig)null, selector, args);
+        }
+
         /// <summary>
         /// Projects each element of a sequence into a new class of type TResult.
         /// Details see <see href="http://solutionizing.net/category/linq/"/>.
         /// </summary>
         /// <typeparam name="TResult">The type of the result.</typeparam>
         /// <param name="source">A sequence of values to project.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="selector">A projection string expression to apply to each element.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters.</param>
         /// <returns>An <see cref="IQueryable{TResult}"/> whose elements are the result of invoking a projection string on each element of source.</returns>
@@ -1048,13 +1170,13 @@ public static IQueryable Select([NotNull] this IQueryable source, [NotNull] stri
         /// ]]>
         /// </code>
         /// </example>
-        public static IQueryable<TResult> Select<TResult>([NotNull] this IQueryable source, [NotNull] string selector, params object[] args)
+        public static IQueryable<TResult> Select<TResult>([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string selector, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(selector, nameof(selector));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, typeof(TResult), selector, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, typeof(TResult), selector, args);
 
             var optimized = OptimizeExpression(Expression.Call(
                 typeof(Queryable), nameof(Queryable.Select),
@@ -1064,11 +1186,18 @@ public static IQueryable<TResult> Select<TResult>([NotNull] this IQueryable sour
             return source.Provider.CreateQuery<TResult>(optimized);
         }
 
+        /// <inheritdoc cref="Select(IQueryable, ParsingConfig, string, object[])"/>
+        public static IQueryable<TResult> Select<TResult>([NotNull] this IQueryable source, [NotNull] string selector, params object[] args)
+        {
+            return Select<TResult>(source, null, selector, args);
+        }
+
         /// <summary>
         /// Projects each element of a sequence into a new class of type TResult.
         /// Details see http://solutionizing.net/category/linq/ 
         /// </summary>
         /// <param name="source">A sequence of values to project.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="resultType">The result type.</param>
         /// <param name="selector">A projection string expression to apply to each element.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters.</param>
@@ -1078,14 +1207,14 @@ public static IQueryable<TResult> Select<TResult>([NotNull] this IQueryable sour
         /// var users = queryable.Select(typeof(User), "new (Username, Pwd as Password)");
         /// </code>
         /// </example>
-        public static IQueryable Select([NotNull] this IQueryable source, [NotNull] Type resultType, [NotNull] string selector, params object[] args)
+        public static IQueryable Select([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] Type resultType, [NotNull] string selector, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotNull(resultType, nameof(resultType));
             Check.NotEmpty(selector, nameof(selector));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, resultType, selector, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, resultType, selector, args);
 
             var optimized = OptimizeExpression(Expression.Call(
                 typeof(Queryable), nameof(Queryable.Select),
@@ -1094,6 +1223,13 @@ public static IQueryable Select([NotNull] this IQueryable source, [NotNull] Type
 
             return source.Provider.CreateQuery(optimized);
         }
+
+        /// <inheritdoc cref="Select(IQueryable, ParsingConfig, Type, string, object[])"/>
+        public static IQueryable Select([NotNull] this IQueryable source, [NotNull] Type resultType, [NotNull] string selector, params object[] args)
+        {
+            return Select(source, null, resultType, selector, args);
+        }
+
         #endregion Select
 
         #region SelectMany
@@ -1101,6 +1237,7 @@ public static IQueryable Select([NotNull] this IQueryable source, [NotNull] Type
         /// Projects each element of a sequence to an <see cref="IQueryable"/> and combines the resulting sequences into one sequence.
         /// </summary>
         /// <param name="source">A sequence of values to project.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="selector">A projection string expression to apply to each element.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters.  Similar to the way String.Format formats strings.</param>
         /// <returns>An <see cref="IQueryable"/> whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.</returns>
@@ -1109,18 +1246,25 @@ public static IQueryable Select([NotNull] this IQueryable source, [NotNull] Type
         /// var roles = users.SelectMany("Roles");
         /// </code>
         /// </example>
-        public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull] string selector, params object[] args)
+        public static IQueryable SelectMany([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string selector, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(selector, nameof(selector));
 
-            return SelectManyInternal(source, null, selector, args);
+            return SelectManyInternal(source, config, null, selector, args);
+        }
+
+        /// <inheritdoc cref="SelectMany(IQueryable, ParsingConfig, string, object[])"/>
+        public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull] string selector, params object[] args)
+        {
+            return SelectMany(source, (ParsingConfig)null, selector, args);
         }
 
         /// <summary>
         /// Projects each element of a sequence to an <see cref="IQueryable"/> and combines the resulting sequences into one sequence.
         /// </summary>
         /// <param name="source">A sequence of values to project.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="selector">A projection string expression to apply to each element.</param>
         /// <param name="resultType">The result type.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
@@ -1130,19 +1274,25 @@ public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull]
         /// var permissions = users.SelectMany(typeof(Permission), "Roles.SelectMany(Permissions)");
         /// </code>
         /// </example>
-        public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull] Type resultType, [NotNull] string selector, params object[] args)
+        public static IQueryable SelectMany([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] Type resultType, [NotNull] string selector, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotNull(resultType, nameof(resultType));
             Check.NotEmpty(selector, nameof(selector));
 
-            return SelectManyInternal(source, resultType, selector, args);
+            return SelectManyInternal(source, config, resultType, selector, args);
         }
 
-        private static IQueryable SelectManyInternal(IQueryable source, Type resultType, string selector, params object[] args)
+        /// <inheritdoc cref="SelectMany(IQueryable, ParsingConfig, Type, string, object[])"/>
+        public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull] Type resultType, [NotNull] string selector, params object[] args)
+        {
+            return SelectMany(source, null, resultType, selector, args);
+        }
+
+        private static IQueryable SelectManyInternal(IQueryable source, ParsingConfig config, Type resultType, string selector, params object[] args)
         {
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, selector, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, selector, args);
 
             //Extra help to get SelectMany to work from StackOverflow Answer
             //http://stackoverflow.com/a/3001674/2465182
@@ -1182,6 +1332,7 @@ private static IQueryable SelectManyInternal(IQueryable source, Type resultType,
         /// </summary>
         /// <typeparam name="TResult">The type of the result.</typeparam>
         /// <param name="source">A sequence of values to project.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="selector">A projection string expression to apply to each element.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>An <see cref="IQueryable{TResult}"/> whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.</returns>
@@ -1192,7 +1343,7 @@ private static IQueryable SelectManyInternal(IQueryable source, Type resultType,
         /// ]]>
         /// </code>
         /// </example>
-        public static IQueryable<TResult> SelectMany<TResult>([NotNull] this IQueryable source, [NotNull] string selector, params object[] args)
+        public static IQueryable<TResult> SelectMany<TResult>([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string selector, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(selector, nameof(selector));
@@ -1215,6 +1366,12 @@ public static IQueryable<TResult> SelectMany<TResult>([NotNull] this IQueryable
             return source.Provider.CreateQuery<TResult>(optimized);
         }
 
+        /// <inheritdoc cref="SelectMany(IQueryable, ParsingConfig, string, object[])"/>
+        public static IQueryable<TResult> SelectMany<TResult>([NotNull] this IQueryable source, [NotNull] string selector, params object[] args)
+        {
+            return SelectMany<TResult>(source, null, selector, args);
+        }
+
         /// <summary>
         /// Projects each element of a sequence to an <see cref="IQueryable"/>
         /// and invokes a result selector function on each element therein. The resulting
@@ -1222,6 +1379,7 @@ public static IQueryable<TResult> SelectMany<TResult>([NotNull] this IQueryable
         /// sequence and returned.
         /// </summary>
         /// <param name="source">A sequence of values to project.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="collectionSelector">A projection function to apply to each element of the input sequence.</param>
         /// <param name="resultSelector">A projection function to apply to each element of each intermediate sequence. Should only use x and y as parameter names.</param>
         /// <param name="collectionSelectorArgs">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
@@ -1238,11 +1396,17 @@ public static IQueryable<TResult> SelectMany<TResult>([NotNull] this IQueryable
         /// ]]>
         /// </code>
         /// </example>
-        public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull] string collectionSelector, [NotNull] string resultSelector, [CanBeNull] object[] collectionSelectorArgs = null, [CanBeNull] params object[] resultSelectorArgs)
+        public static IQueryable SelectMany([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string collectionSelector, [NotNull] string resultSelector, [CanBeNull] object[] collectionSelectorArgs = null, [CanBeNull] params object[] resultSelectorArgs)
         {
             return SelectMany(source, collectionSelector, resultSelector, "x", "y", collectionSelectorArgs, resultSelectorArgs);
         }
 
+        /// <inheritdoc cref="SelectMany(IQueryable, ParsingConfig, string, object[])"/>
+        public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull] string collectionSelector, [NotNull] string resultSelector, [CanBeNull] object[] collectionSelectorArgs = null, [CanBeNull] params object[] resultSelectorArgs)
+        {
+            return SelectMany(source, (ParsingConfig)null, collectionSelector, resultSelector, "x", "y", collectionSelectorArgs, resultSelectorArgs);
+        }
+
         /// <summary>
         /// Projects each element of a sequence to an <see cref="IQueryable"/>
         /// and invokes a result selector function on each element therein. The resulting
@@ -1250,6 +1414,7 @@ public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull]
         /// sequence and returned.
         /// </summary>
         /// <param name="source">A sequence of values to project.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="collectionSelector">A projection function to apply to each element of the input sequence.</param>
         /// <param name="collectionParameterName">The name from collectionParameter to use. Default is x.</param>
         /// <param name="resultSelector">A projection function to apply to each element of each intermediate sequence.</param>
@@ -1268,8 +1433,7 @@ public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull]
         /// ]]>
         /// </code>
         /// </example>
-        public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull] string collectionSelector, [NotNull] string resultSelector,
-            [NotNull] string collectionParameterName, [NotNull] string resultParameterName, [CanBeNull] object[] collectionSelectorArgs = null, [CanBeNull] params object[] resultSelectorArgs)
+        public static IQueryable SelectMany([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string collectionSelector, [NotNull] string resultSelector, [NotNull] string collectionParameterName, [NotNull] string resultParameterName, [CanBeNull] object[] collectionSelectorArgs = null, [CanBeNull] params object[] resultSelectorArgs)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(collectionSelector, nameof(collectionSelector));
@@ -1278,7 +1442,7 @@ public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull]
             Check.NotEmpty(resultParameterName, nameof(resultParameterName));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression sourceSelectLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, collectionSelector, collectionSelectorArgs);
+            LambdaExpression sourceSelectLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, collectionSelector, collectionSelectorArgs);
 
             //we have to adjust to lambda to return an IEnumerable<T> instead of whatever the actual property is.
             Type sourceLambdaInputType = source.Expression.Type.GetGenericArguments()[0];
@@ -1292,7 +1456,7 @@ public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull]
             ParameterExpression xParameter = ParameterExpressionHelper.CreateParameterExpression(source.ElementType, collectionParameterName);
             ParameterExpression yParameter = ParameterExpressionHelper.CreateParameterExpression(sourceLambdaResultType, resultParameterName);
 
-            LambdaExpression resultSelectLambda = DynamicExpressionParser.ParseLambda(createParameterCtor, new[] { xParameter, yParameter }, null, resultSelector, resultSelectorArgs);
+            LambdaExpression resultSelectLambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, new[] { xParameter, yParameter }, null, resultSelector, resultSelectorArgs);
             Type resultLambdaResultType = resultSelectLambda.Body.Type;
 
             var optimized = OptimizeExpression(Expression.Call(
@@ -1303,6 +1467,13 @@ public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull]
 
             return source.Provider.CreateQuery(optimized);
         }
+
+        /// <inheritdoc cref="SelectMany(IQueryable, ParsingConfig, string, string, string, string, object[], object[])"/>
+        public static IQueryable SelectMany([NotNull] this IQueryable source, [NotNull] string collectionSelector, [NotNull] string resultSelector, [NotNull] string collectionParameterName, [NotNull] string resultParameterName, [CanBeNull] object[] collectionSelectorArgs = null, [CanBeNull] params object[] resultSelectorArgs)
+        {
+            return SelectMany(source, null, collectionSelector, resultSelector, collectionParameterName, resultParameterName, collectionSelectorArgs, resultSelectorArgs);
+        }
+
         #endregion SelectMany
 
         #region Single/SingleOrDefault
@@ -1331,24 +1502,35 @@ public static dynamic Single([NotNull] this IQueryable source)
         /// is not exactly one element in the sequence.
         /// </summary>
         /// <param name="source">The <see cref="IQueryable"/> to return the last element of.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>The first element in source that passes the test in predicate.</returns>
 #if NET35
-        public static object Single([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static object Single([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #else
-        public static dynamic Single([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static dynamic Single([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #endif
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(predicate, nameof(predicate));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, predicate, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, predicate, args);
 
             return Execute(_singlePredicate, source, lambda);
         }
 
+        /// <inheritdoc cref="Single(IQueryable, ParsingConfig, string, object[])"/>
+#if NET35
+        public static object Single([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#else
+        public static dynamic Single([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#endif
+        {
+            return Single(source, null, predicate, args);
+        }
+
         /// <summary>
         /// Returns the only element of a sequence that satisfies a specified condition, and throws an exception if there
         /// is not exactly one element in the sequence.
@@ -1392,24 +1574,35 @@ public static dynamic SingleOrDefault([NotNull] this IQueryable source)
         /// is empty; and throws an exception if there is not exactly one element in the sequence.
         /// </summary>
         /// <param name="source">The <see cref="IQueryable"/> to return the last element of.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>The first element in source that passes the test in predicate.</returns>
 #if NET35
-        public static object SingleOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static object SingleOrDefault([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #else
-        public static dynamic SingleOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+        public static dynamic SingleOrDefault([NotNull] this IQueryable source,  [CanBeNull] ParsingConfig config, [NotNull] string predicate, params object[] args)
 #endif
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(predicate, nameof(predicate));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, predicate, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, predicate, args);
 
             return Execute(_singleDefaultPredicate, source, lambda);
         }
 
+        /// <inheritdoc cref="SingleOrDefault(IQueryable, ParsingConfig, string, object[])"/>
+#if NET35
+        public static object SingleOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#else
+        public static dynamic SingleOrDefault([NotNull] this IQueryable source, [NotNull] string predicate, params object[] args)
+#endif
+        {
+            return SingleOrDefault(source, null, predicate, args);
+        }
+
         /// <summary>
         /// Returns the only element of a sequence that satisfies a specified condition or a default value if the sequence
         /// is empty; and throws an exception if there is not exactly one element in the sequence.
@@ -1457,6 +1650,7 @@ public static IQueryable Skip([NotNull] this IQueryable source, int count)
         /// Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
         /// </summary>
         /// <param name="source">A sequence to check for being empty.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <example>
@@ -1467,16 +1661,23 @@ public static IQueryable Skip([NotNull] this IQueryable source, int count)
         /// </code>
         /// </example>
         /// <returns>An <see cref="IQueryable"/> that contains elements from source starting at the first element in the linear series that does not pass the test specified by predicate.</returns>
-        public static IQueryable SkipWhile([NotNull] this IQueryable source, [NotNull] string predicate, [CanBeNull] params object[] args)
+        public static IQueryable SkipWhile([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, [CanBeNull] params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotNull(predicate, nameof(predicate));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, predicate, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, predicate, args);
 
             return CreateQuery(_skipWhilePredicate, source, lambda);
         }
+
+        /// <inheritdoc cref="SkipWhile(IQueryable, ParsingConfig, string, object[])"/>
+        public static IQueryable SkipWhile([NotNull] this IQueryable source, [NotNull] string predicate, [CanBeNull] params object[] args)
+        {
+            return SkipWhile(source, null, predicate, args);
+        }
+
         #endregion SkipWhile
 
         #region Sum
@@ -1518,6 +1719,7 @@ public static IQueryable Take([NotNull] this IQueryable source, int count)
         /// Returns elements from a sequence as long as a specified condition is true.
         /// </summary>
         /// <param name="source">A sequence to check for being empty.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="predicate">A function to test each element for a condition.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <example>
@@ -1528,16 +1730,23 @@ public static IQueryable Take([NotNull] this IQueryable source, int count)
         /// </code>
         /// </example>
         /// <returns>An <see cref="IQueryable"/> that contains elements from the input sequence occurring before the element at which the test specified by predicate no longer passes.</returns>
-        public static IQueryable TakeWhile([NotNull] this IQueryable source, [NotNull] string predicate, [CanBeNull] params object[] args)
+        public static IQueryable TakeWhile([NotNull] this IQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string predicate, [CanBeNull] params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotNull(predicate, nameof(predicate));
 
             bool createParameterCtor = source.IsLinqToObjects();
-            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(createParameterCtor, source.ElementType, null, predicate, args);
+            LambdaExpression lambda = DynamicExpressionParser.ParseLambda(config, createParameterCtor, source.ElementType, null, predicate, args);
 
             return CreateQuery(_takeWhilePredicate, source, lambda);
         }
+
+        /// <inheritdoc cref="TakeWhile(IQueryable, ParsingConfig, string, object[])"/>
+        public static IQueryable TakeWhile([NotNull] this IQueryable source, [NotNull] string predicate, [CanBeNull] params object[] args)
+        {
+            return TakeWhile(source, null, predicate, args);
+        }
+
         #endregion TakeWhile
 
         #region ThenBy
@@ -1546,6 +1755,7 @@ public static IQueryable TakeWhile([NotNull] this IQueryable source, [NotNull] s
         /// </summary>
         /// <typeparam name="TSource">The type of the elements of source.</typeparam>
         /// <param name="source">A sequence of values to order.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="ordering">An expression string to indicate values to order by.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
         /// <returns>A <see cref="IOrderedQueryable{T}"/> whose elements are sorted according to the specified <paramref name="ordering"/>.</returns>
@@ -1559,15 +1769,21 @@ public static IQueryable TakeWhile([NotNull] this IQueryable source, [NotNull] s
         /// ]]>
         /// </code>
         /// </example>
-        public static IOrderedQueryable<TSource> ThenBy<TSource>([NotNull] this IOrderedQueryable<TSource> source, [NotNull] string ordering, params object[] args)
+        public static IOrderedQueryable<TSource> ThenBy<TSource>([NotNull] this IOrderedQueryable<TSource> source, [CanBeNull] ParsingConfig config, [NotNull] string ordering, params object[] args)
         {
-            return (IOrderedQueryable<TSource>)ThenBy((IOrderedQueryable)source, ordering, args);
+            return (IOrderedQueryable<TSource>)ThenBy((IOrderedQueryable)source, config, ordering, args);
         }
 
+        /// <inheritdoc cref="ThenBy(IOrderedQueryable{TSource}, ParsingConfig, string, object[])"/>
+        public static IOrderedQueryable<TSource> ThenBy<TSource>([NotNull] this IOrderedQueryable<TSource> source, [NotNull] string ordering, params object[] args)
+        {
+            return (IOrderedQueryable<TSource>)ThenBy<TSource>(source, (ParsingConfig)null, ordering, args);
+        }
         /// <summary>
         /// Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.
         /// </summary>
         /// <param name="source">A sequence of values to order.</param>
+        /// <param name="config">The <see cref="ParsingConfig"/>.</param>
         /// <param name="ordering">An expression string to indicate values to order by.</param>
         /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters.  Similar to the way String.Format formats strings.</param>
         /// <returns>A <see cref="IQueryable"/> whose elements are sorted according to the specified <paramref name="ordering"/>.</returns>
@@ -1579,13 +1795,13 @@ public static IOrderedQueryable<TSource> ThenBy<TSource>([NotNull] this IOrdered
         /// var resultMultiple = result.OrderBy("NumberProperty, StringProperty DESC");
         /// </code>
         /// </example>
-        public static IOrderedQueryable ThenBy([NotNull] this IOrderedQueryable source, [NotNull] string ordering, params object[] args)
+        public static IOrderedQueryable ThenBy([NotNull] this IOrderedQueryable source, [CanBeNull] ParsingConfig config, [NotNull] string ordering, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotEmpty(ordering, nameof(ordering));
 
             ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(source.ElementType, string.Empty) };
-            ExpressionParser parser = new ExpressionParser(parameters, ordering, args, null);
+            ExpressionParser parser = new ExpressionParser(parameters, ordering, args, config);
             IList<DynamicOrdering> dynamicOrderings = parser.ParseOrdering(forceThenBy: true);
 
             Expression queryExpr = source.Expression;
@@ -1601,6 +1817,13 @@ public static IOrderedQueryable ThenBy([NotNull] this IOrderedQueryable source,
             var optimized = OptimizeExpression(queryExpr);
             return (IOrderedQueryable)source.Provider.CreateQuery(optimized);
         }
+
+        /// <inheritdoc cref="ThenBy(IOrderedQueryable, ParsingConfig, string, object[])"/>
+        public static IOrderedQueryable ThenBy([NotNull] this IOrderedQueryable source, [NotNull] string ordering, params object[] args)
+        {
+            return ThenBy(source, null, ordering, args);
+        }
+
         #endregion OrderBy
 
         #region Where
diff --git a/test/System.Linq.Dynamic.Core.Tests/ExpressionTests.cs b/test/System.Linq.Dynamic.Core.Tests/ExpressionTests.cs
index 154c66fe..af22335b 100644
--- a/test/System.Linq.Dynamic.Core.Tests/ExpressionTests.cs
+++ b/test/System.Linq.Dynamic.Core.Tests/ExpressionTests.cs
@@ -578,6 +578,31 @@ public void ExpressionTests_Enum()
             Check.That(resultEqualStringMixedCaseParamRight.Single()).Equals(TestEnum.Var5);
         }
 
+        [Fact]
+        public void ExpressionTests_ConfigExtensions()
+        {
+            var config = new ParsingConfig();
+#if NETSTANDARD            
+            config.CustomTypeProvider = new NetStandardCustomTypeProvider();
+#endif
+
+            // Arrange
+            var lst = new List<TestEnum> { TestEnum.Var1, TestEnum.Var2, TestEnum.Var3, TestEnum.Var4, TestEnum.Var5, TestEnum.Var6 };
+            var qry = lst.AsQueryable();
+
+            // Act
+            var r1 = qry.Any(config, "it < TestEnum.Var4");
+            var r2 = qry.First(config, "TestEnum.Var4 > it");
+            var r3 = qry.FirstOrDefault(config, "it = Var5");
+            var r4 = qry.Last(config, "@0 = it", TestEnum.Var5);
+            var r5 = qry.LastOrDefault("@0 = it", 8);
+            var r6 = qry.Single(config, "it = @0", "Var5");
+            var r7 = qry.SingleOrDefault(config, "@0 = it", "vAR5");
+            var r8 = qry.SkipWhile(config, "it < TestEnum.Var4").FirstOrDefault();
+            var r9 = qry.TakeWhile(config, "it < TestEnum.Var4").FirstOrDefault();
+            var r10 = qry.GroupBy(config, "it").FirstOrDefault();
+        }
+
         [Fact]
         public void ExpressionTests_Enum_Nullable()
         {

From 7e9b01acaf10123a027fb89f45812e44ccd3f5dc Mon Sep 17 00:00:00 2001
From: Stef Heyenrath <Stef.Heyenrath@gmail.com>
Date: Sun, 6 May 2018 11:16:56 +0200
Subject: [PATCH 2/2] Update versions

---
 ChangeLog.txt                                                   | 2 +-
 .../EntityFramework.DynamicLinq.csproj                          | 2 +-
 .../Microsoft.EntityFrameworkCore.DynamicLinq.csproj            | 2 +-
 src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj    | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/ChangeLog.txt b/ChangeLog.txt
index ffcfe2c5..ac3a8c49 100644
--- a/ChangeLog.txt
+++ b/ChangeLog.txt
@@ -1,5 +1,5 @@
 https://github.com/GitTools/GitReleaseNotes
 
-GitReleaseNotes.exe . /OutputFile CHANGELOG.md /Version 1.0.8.6
+GitReleaseNotes.exe . /OutputFile CHANGELOG.md /Version 1.0.8.7
 
 GitReleaseNotes.exe . /OutputFile CHANGELOG.md /allTags
diff --git a/src/EntityFramework.DynamicLinq/EntityFramework.DynamicLinq.csproj b/src/EntityFramework.DynamicLinq/EntityFramework.DynamicLinq.csproj
index 80bea81c..cbb3ea0e 100644
--- a/src/EntityFramework.DynamicLinq/EntityFramework.DynamicLinq.csproj
+++ b/src/EntityFramework.DynamicLinq/EntityFramework.DynamicLinq.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>Dynamic Linq extensions for EntityFramework which adds Async support</Description>
     <AssemblyTitle>EntityFramework.DynamicLinq</AssemblyTitle>
-    <VersionPrefix>1.0.8.6</VersionPrefix>
+    <VersionPrefix>1.0.8.7</VersionPrefix>
     <Authors>Stef Heyenrath</Authors>
     <TargetFrameworks>net45;net46</TargetFrameworks>
     <DefineConstants>EF</DefineConstants>
diff --git a/src/Microsoft.EntityFrameworkCore.DynamicLinq/Microsoft.EntityFrameworkCore.DynamicLinq.csproj b/src/Microsoft.EntityFrameworkCore.DynamicLinq/Microsoft.EntityFrameworkCore.DynamicLinq.csproj
index 3b64420e..237e2186 100644
--- a/src/Microsoft.EntityFrameworkCore.DynamicLinq/Microsoft.EntityFrameworkCore.DynamicLinq.csproj
+++ b/src/Microsoft.EntityFrameworkCore.DynamicLinq/Microsoft.EntityFrameworkCore.DynamicLinq.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>Dynamic Linq extensions for Microsoft.EntityFrameworkCore which adds Async support</Description>
     <AssemblyTitle>Microsoft.EntityFrameworkCore.DynamicLinq</AssemblyTitle>
-    <VersionPrefix>1.0.8.6</VersionPrefix>
+    <VersionPrefix>1.0.8.7</VersionPrefix>
     <Authors>Stef Heyenrath</Authors>
     <TargetFrameworks>net451;net46;netstandard1.3;netstandard2.0;uap10.0</TargetFrameworks>
     <DefineConstants>$(DefineConstants);EFCORE</DefineConstants>
diff --git a/src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj b/src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj
index a0388560..3468e6c3 100644
--- a/src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj
+++ b/src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>This is a .NETStandard/ .NET Core port of the the Microsoft assembly for the .Net 4.0 Dynamic language functionality.</Description>
     <AssemblyTitle>System.Linq.Dynamic.Core</AssemblyTitle>
-    <VersionPrefix>1.0.8.6</VersionPrefix>
+    <VersionPrefix>1.0.8.7</VersionPrefix>
     <Authors>Microsoft;Scott Guthrie;King Wilder;Nathan Arnott;Stef Heyenrath</Authors>
     <TargetFrameworks>net35;net40;net45;net46;uap10.0;netstandard1.3;netstandard2.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>