public static bool TryParse <T>(this string exp, out Expression expression, out T t)
{
expression = null;
t = default(T);
if (string.IsNullOrEmpty(exp))
{
return(false);
}
//throw new ArgumentNullException(nameof(exp));
try
{
var externals = new Dictionary <string, object>
{
{ "x", 5 },
{ "y", Math.PI }
};
externals["x"] = 6;
expression = DynamicExpression.ParseLambda(new ParameterExpression[] {}, typeof(T), exp, externals);
t = (T)((LambdaExpression)expression).Compile().DynamicInvoke();
}catch (Exception ex)
{
System.Console.WriteLine("Exception: " + ex);
return(false);
}
return(true);
}
public bool TryEvaluateExpression <TValue>(string expression, out TValue value)
{
value = default(TValue);
try
{
var parsed = ParseExpression(expression);
var exp = parsed.Item1;
var p = parsed.Item2.Select(v => Expression.Parameter(v.Value.GetType(), v.Key));
var e = DynamicExpression.ParseLambda(p.ToArray(), null, exp);
var result = e.Compile().DynamicInvoke(parsed.Item2.Select(v => v.Value).ToArray());
value = ConverterHelper.Convert <TValue>(result);
}
catch (Exception ex)
{
_logger.Log(ex);
// Use default value
return(false);
}
return(true);
}
protected virtual IEnumerable <TViewModel> GetByCriteria <TAggregateRoot, TViewModel>(
IRepository <TAggregateRoot> repository,
string filterExpression = null, string sortingField = null, SortOrder?sortingOrder = null)
where TAggregateRoot : class, IAggregateRoot
where TViewModel : ViewModel
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
Specification <TAggregateRoot> querySpecification = new AnySpecification <TAggregateRoot>();
if (!string.IsNullOrEmpty(filterExpression))
{
querySpecification =
Specification <TAggregateRoot> .Eval(
DynamicExpression.ParseLambda <TAggregateRoot, bool>(filterExpression));
}
Expression <Func <TAggregateRoot, dynamic> > sortPredicate = null;
var sortOrder = sortingOrder ?? SortOrder.Unspecified;
if (!string.IsNullOrEmpty(sortingField))
{
sortPredicate = DynamicExpression.ParseLambda <TAggregateRoot, dynamic>(sortingField);
}
return(repository.FindAll(querySpecification, sortPredicate, sortOrder).Project().To <TViewModel>());
}
public void TestMethod_Get_Region_By_Predicate()
{
var repositoryMock = new Mock <IEmployeeRepository>();
repositoryMock.Setup(x => x.GetAll()).Returns(_employees);
var allRegion = new RepositoryTest(repositoryMock.Object);
string[] keywords = new string[2] {
"o", "a"
};
Expression <Func <Employee, bool> > predicate = PredicateBuilder.False <Employee>();
ParameterExpression it = Expression.Parameter(typeof(string), "fn");
string str = String.Format("it.{0}.Contains(@0)", "FirstName");
string str1 = String.Format("it.{0}.Contains(@0)", "LastName");
var e = DynamicExpression.ParseLambda <Employee, bool>(str, "a");
var e1 = DynamicExpression.ParseLambda <Employee, bool>(str1, "a");
Expression <Func <Employee, bool> > predicate1 = e.And(e1);
//foreach (string keyword in keywords)
//{
// string temp = keyword;
// predicate = predicate.Or(p => p.LastName.Contains(temp));
//}
//IEnumerable<T> FindBy(System.Linq.Expressions.Expression<Func<T, bool>> predicate)
IEnumerable <Employee> listRegion = allRegion.FindBy(predicate1);
int count = listRegion.Count();
//Assert
Assert.IsNotNull(listRegion); // Test if null
Assert.IsInstanceOfType(typeof(IEnumerable <Employee>), listRegion);
Assert.AreEqual(1, count);
}
/**
* Given a string, we create an Expression, to be used as a predicate.
*
* ```cs
* using Graceful.Dynamic;
*
* Expression<Func<T, bool>> compliedExpression =
* e => e.Id == 1;
*
* Expression<Func<T, bool>> builtExpression =
* ExpressionBuilder.BuildPredicateExpression<Foo>("e.Id == 1");
*
* compliedExpression == builtExpression
* ```
*
* > NOTE: You must always use the parameter of _"e"_.
*/
public static Expression <Func <T, bool> > BuildPredicateExpression <T>(string expression)
{
try
{
if (!string.IsNullOrEmpty(expression))
{
return((Expression <Func <T, bool> >)DynamicExpression.ParseLambda
(
new[] { Expression.Parameter(typeof(T), "e") },
typeof(bool),
expression
));
}
else
{
return(null);
}
}
catch (System.Linq.Dynamic.ParseException parseEx)
{
throw parseEx;
}
finally
{
}
}
/// <summary>
/// Evaluates the parameter.
/// </summary>
/// <param name = "expression">The expression.</param>
/// <param name = "context">The context.</param>
/// <param name = "resultType">Type of the result.</param>
/// <returns>The evaluated parameter.</returns>
private static object EvaluateParameter(string expression, ActionExecutionContext context, Type resultType)
{
try
{
var index = 0;
var parameters = new ParameterExpression[MessageBinder.SpecialValues.Count];
var values = new object[MessageBinder.SpecialValues.Count];
foreach (var pair in MessageBinder.SpecialValues)
{
var name = "@" + index;
expression = expression.Replace(pair.Key, name);
var value = pair.Value(context);
parameters[index] = Expression.Parameter(GetParameterType(value), name);
values[index] = value;
index++;
}
var exp = DynamicExpression.ParseLambda(parameters, resultType, expression);
return(exp.Compile().DynamicInvoke(values));
}
catch (Exception exc)
{
LogManager.GetLog(typeof(MessageBinder)).Error(exc);
return(null);
}
}
/**
* Create an Expression, to be used for property selection.
*
* ```cs
* using Graceful.Dynamic;
*
* Expression<Func<T, object>> compliedExpression =
* e => e.CreatedAt;
*
* Expression<Func<T, object>> builtExpression =
* ExpressionBuilder.BuildPropertySelectExpression<Foo>
* (
* "e.CreatedAt"
* );
*
* // compliedExpression == builtExpression
*
* Foo.Where(e => e.Bar == "Baz").OrderBy(builtExpression).ToList();
* ```
*
* > NOTE: You must always use the parameter of _"e"_.
*/
public static Expression <Func <T, object> > BuildPropertySelectExpression <T>(string expression)
{
return((Expression <Func <T, object> >)DynamicExpression.ParseLambda
(
new[] { Expression.Parameter(typeof(T), "e") },
typeof(object),
expression
));
}
/**
* Given a string, we create an Expression, to be used as a predicate.
*
* ```cs
* using Graceful.Dynamic;
*
* Expression<Func<T, bool>> compliedExpression =
* e => e.Id == 1;
*
* Expression<Func<T, bool>> builtExpression =
* ExpressionBuilder.BuildPredicateExpression<Foo>("e.Id == 1");
*
* compliedExpression == builtExpression
* ```
*
* > NOTE: You must always use the parameter of _"e"_.
*/
public static Expression <Func <T, bool> > BuildPredicateExpression <T>(string expression)
{
return((Expression <Func <T, bool> >)DynamicExpression.ParseLambda
(
new[] { Expression.Parameter(typeof(T), "e") },
typeof(bool),
expression
));
}
/// <summary>
/// Gets the by criteria.
/// </summary>
/// <typeparam name="TAggregateRoot">The type of the aggregate root.</typeparam>
/// <typeparam name="TViewModel">The type of the view model.</typeparam>
/// <param name="repository">The repository.</param>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">repository</exception>
/// <exception cref="System.InvalidOperationException">
/// Cannot perform a paging query: The paging query requires the sorting
/// but neither SortPredicate nor SortOrder was specified.
/// </exception>
protected virtual IEnumerable <TViewModel> GetByCriteria <TAggregateRoot, TViewModel>(
IRepository <TAggregateRoot> repository,
QueryCriteria criteria)
where TAggregateRoot : class, IAggregateRoot
where TViewModel : ViewModel
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (criteria == null)
{
return(repository.FindAll()
.Project().To <TViewModel>());
}
Specification <TAggregateRoot> querySpecification = new AnySpecification <TAggregateRoot>();
if (!string.IsNullOrEmpty(criteria.FilterExpression))
{
querySpecification =
Specification <TAggregateRoot> .Eval(
DynamicExpression.ParseLambda <TAggregateRoot, bool>(criteria.FilterExpression));
}
Expression <Func <TAggregateRoot, dynamic> > sortPredicate = null;
if (!string.IsNullOrEmpty(criteria.SortingField))
{
sortPredicate = DynamicExpression.ParseLambda <TAggregateRoot, dynamic>(criteria.SortingField);
}
var sortOrder = SortOrder.Unspecified;
if (criteria.SortingOrder.HasValue)
{
sortOrder = criteria.SortingOrder.Value;
}
if (criteria.PageSize.HasValue && criteria.PageNumber.HasValue)
{
if (sortPredicate == null || sortOrder == SortOrder.Unspecified)
{
throw new InvalidOperationException(
"Cannot perform a paging query: The paging query requires the sorting but neither SortPredicate nor SortOrder was specified.");
}
return(repository.FindAll(querySpecification, sortPredicate, sortOrder,
criteria.PageNumber.Value, criteria.PageSize.Value)
.CastPagedResult <TAggregateRoot, TViewModel>(Mapper.Map <TAggregateRoot, TViewModel>));
}
return(repository
.FindAll(querySpecification, sortPredicate, sortOrder)
.Project()
.To <TViewModel>());
}
private IEnumerable <SyntaxToken> ExtractExpressionTreeTokens(Compilation compilation)
{
var tokensParam = Expression.Parameter(typeof(IEnumerable <SyntaxToken>), "tokens");
var expression =
DynamicExpression.ParseLambda(new[] { tokensParam }, typeof(IEnumerable <SyntaxToken>), TokenSelector);
var tree = compilation.SyntaxTrees.Single();
var tokens = tree.GetRoot().DescendantTokens(c => true);
var myTokens = (IEnumerable <SyntaxToken>)expression.Compile().DynamicInvoke(tokens);
return(myTokens);
}
protected override bool CheckResult(string consoleOut)
{
var lines = consoleOut.Split(new string[] { "\r", "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
var lastLine = lines[lines.Length - 1];
var lastLineParam = Expression.Parameter(typeof(string), "output");
var expression = DynamicExpression.ParseLambda(new[] { lastLineParam }, typeof(bool), Condition);
var result = (bool)expression.Compile().DynamicInvoke(lastLine);
return(result);
}
public void AccessEnumInExpressionWorks()
{
var expression = "it == Int32(MyEnum.Yes)";
var expr = (Expression <Func <int, bool> >)DynamicExpression.ParseLambda(typeof(int), typeof(bool), expression, additionalAllowedTypes: new[] { typeof(MyEnum) });
Assert.NotNull(expr);
var func = expr.Compile();
Assert.True(func((int)MyEnum.Yes));
Assert.False(func((int)MyEnum.No));
}
/**
* Create an expression that checks for equality of all properties.
*
* ```cs
* using Graceful.Dynamic;
*
* var e2 = new Foo
* {
* Bar = "abc",
* Baz = 123
* };
*
* Expression<Func<T, bool>> compliedExpression =
* e1 => e1.Bar == e2.Bar && e1.Baz == e2.Baz;
*
* Expression<Func<T, bool>> builtExpression =
* ExpressionBuilder.BuildEqualityExpression<Foo>(e2);
*
* // compliedExpression == builtExpression
* ```
*
* > NOTE: Some properties are excluded from the equality check,
* > such as Id, CreatedAt, ModifiedAt & DeletedAt. Also beaware
* > only primatives are checked, relationships are completely ignored.
*/
public static Expression <Func <T, bool> > BuildEqualityExpression <T>(T e2) where T : Model <T>, new()
{
var expressionString = new StringBuilder();
/*
* // Grab our properties
* var props = Graceful.Model.Dynamic(e2).MappedPropsExceptId;
*
* // Remove all properties that are not primatives.
* props.RemoveAll(prop => !TypeMapper.IsClrType(prop.PropertyType));
*
* // Remove all properties that have null values.
* props.RemoveAll(prop => prop.GetValue(e2) == null);
*
* // Remove the CreatedAt, ModifiedAt & DeletedAt timestamps
* props.RemoveAll(prop => prop.Name == "CreatedAt");
* props.RemoveAll(prop => prop.Name == "ModifiedAt");
* props.RemoveAll(prop => prop.Name == "DeletedAt");
*
* // Loop through each property
* props.ForEach(prop =>
* {
* // Build our lamda expression
* expressionString.Append("e1.");
* expressionString.Append(prop.Name);
* expressionString.Append(" == e2.");
* expressionString.Append(prop.Name);
* expressionString.Append(" && ");
* });
*/
// If nothing was added to our expression bail out.
if (expressionString.Length == 0)
{
return(null);
}
// Remove the last &&
expressionString.Remove(expressionString.Length - 4, 4);
// Build the expression
return((Expression <Func <T, bool> >)DynamicExpression.ParseLambda
(
new[] { Expression.Parameter(typeof(T), "e1") },
typeof(bool),
expressionString.ToString(),
new Dictionary <string, object> {
{ "e2", e2 }
}
));
}
private bool EvaluateValidationCondition <T>(T target, IValidationCondition validationCondition)
{
if (!_validationConditionResultDictionary.ContainsKey(validationCondition.ValidationConditionID))
{
ParameterExpression parameterExpression = Expression.Parameter(typeof(T), typeof(T).Name);
LambdaExpression expression = DynamicExpression.ParseLambda(new[] { parameterExpression }, typeof(bool), validationCondition.Expression);
bool outcome = (bool)expression.Compile().DynamicInvoke(target);
_validationConditionResultDictionary.Add(validationCondition.ValidationConditionID, outcome);
}
return(_validationConditionResultDictionary[validationCondition.ValidationConditionID]);
}
protected override Task <bool> AssessCompilationAsync(Compilation compilation)
{
var tree = compilation.SyntaxTrees.Single();
var tokens = tree.GetRoot().DescendantTokens(c => true);
bool result;
var tokensParam = Expression.Parameter(typeof(IEnumerable <SyntaxToken>), "tokens");
var expression = DynamicExpression.ParseLambda(new[] { tokensParam }, typeof(bool), Condition);
result = (bool)expression.Compile().DynamicInvoke(tokens);
return(Task.FromResult(result));
}
public void CanParseFirstOrDefaultExpressionWithoutParams()
{
var expression = "FirstOrDefault()";
var expr = (Expression <Func <IEnumerable <string>, string> >)DynamicExpression.ParseLambda(typeof(IEnumerable <string>), typeof(string), expression);
Console.WriteLine(expr);
Assert.NotNull(expr);
var func = expr.Compile();
Assert.Equal("1", func(new[] { "1", "2", "3" }));
Assert.Null(func(new string[] { }));
}
public void ParseSimpleExpressionWorks()
{
var expression = @"x.Length == 4";
var expr = (Expression <Func <string, bool> >)DynamicExpression.ParseLambda(new[] { Expression.Parameter(typeof(string), "x") }, typeof(bool), expression);
Assert.NotNull(expr);
var values = new[] { "bar", "dog", "food", "water" }.AsQueryable();
var results = values.Where(expr).ToList();
Assert.Equal(1, results.Count);
Assert.Equal("food", results[0]);
}
public void EnumWithoutCastIsConvertedFromInt32ToInt64()
{
var expression = "it == MyEnum.Yes";
var expr = (Expression <Func <long, bool> >)DynamicExpression.ParseLambda(typeof(long), typeof(bool), expression, additionalAllowedTypes: new[] { typeof(MyEnum) });
Console.WriteLine(expr);
Assert.NotNull(expr);
var func = expr.Compile();
Assert.True(func((long)MyEnum.Yes));
Assert.False(func((long)MyEnum.No));
}
public void ParseSubQueryExpressionWorks()
{
var expression = "x.Any(it == 'a')";
var expr = (Expression <Func <IEnumerable <char>, bool> >)DynamicExpression.ParseLambda(new[] { Expression.Parameter(typeof(IEnumerable <char>), "x") }, typeof(bool), expression);
Assert.NotNull(expr);
var values = new[] { "bar", "dog", "food", "water" }.AsQueryable();
var results = values.Where(expr).ToList();
Assert.Equal(2, results.Count);
Assert.Equal("bar", results[0]);
Assert.Equal("water", results[1]);
}
public IQueryable <TResult> Join(IQueryable outer, IEnumerable inner, string outerSelector, string innerSelector, string resultsSelector, params object[] values)
{
if (inner == null)
{
throw new ArgumentNullException("inner");
}
if (outerSelector == null)
{
throw new ArgumentNullException("outerSelector");
}
if (innerSelector == null)
{
throw new ArgumentNullException("innerSelector");
}
if (resultsSelector == null)
{
throw new ArgumentNullException("resultsSelctor");
}
LambdaExpression outerSelectorLambda = DynamicExpression.ParseLambda(outer.ElementType, null, outerSelector, values);
LambdaExpression innerSelectorLambda = DynamicExpression.ParseLambda(inner.AsQueryable().ElementType, null, innerSelector, values);
ParameterExpression[] parameters = new ParameterExpression[] {
Expression.Parameter(outer.ElementType, "outer"), Expression.Parameter(inner.AsQueryable().ElementType, "inner")
};
LambdaExpression resultsSelectorLambda = DynamicExpression.ParseLambda(parameters, null, resultsSelector, values);
IQueryable joinQuery = outer.Provider.CreateQuery(
Expression.Call(
typeof(Queryable), "Join",
new Type[] { outer.ElementType, inner.AsQueryable().ElementType, outerSelectorLambda.Body.Type, resultsSelectorLambda.Body.Type },
outer.Expression, inner.AsQueryable().Expression, Expression.Quote(outerSelectorLambda), Expression.Quote(innerSelectorLambda), Expression.Quote(resultsSelectorLambda)));
IList <TResult> tResultsList = new List <TResult>();
foreach (dynamic r in joinQuery)
{
TResult r1 = Cast <TResult>(r, 2);
tResultsList.Add(r1);
//PersonalTbl emp2 = presonalGrade.Cast<PersonalTbl>(r);
//personalTbls.Add(emp2);
}
return(tResultsList.AsQueryable());
//return (IQueryable) Cast<TResult>(joinQuery);
}
public void CanParseNew()
{
var expression = "new(resource.Length alias Len)";
var parameters = new[]
{
Expression.Parameter(typeof(string), "resource"),
};
var expr = (Expression <Func <string, object> >)DynamicExpression.ParseLambda(parameters, typeof(object), expression);
Console.WriteLine(expr);
Assert.NotNull(expr);
var func = expr.Compile();
}
/// <summary>
/// Gets the paged result by criteria.
/// </summary>
/// <typeparam name="TAggregateRoot">The type of the aggregate root.</typeparam>
/// <typeparam name="TViewModel">The type of the view model.</typeparam>
/// <param name="repository">The repository.</param>
/// <param name="pageNumber">The page number.</param>
/// <param name="pageSize">Size of the page.</param>
/// <param name="sortingField">The sorting field.</param>
/// <param name="sortingOrder">The sorting order.</param>
/// <param name="filterExpression">The filter expression.</param>
/// <param name="expressionArgs">The expression arguments.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">
/// repository
/// or
/// sortingField
/// </exception>
protected virtual PagedResult <TViewModel> GetPagedResultByCriteria <TAggregateRoot, TViewModel>(
IRepository <TAggregateRoot> repository,
int pageNumber, int pageSize, string sortingField, SortOrder sortingOrder, string filterExpression = null,
params object[] expressionArgs)
where TAggregateRoot : class, IAggregateRoot
where TViewModel : ViewModel
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (string.IsNullOrEmpty(sortingField))
{
throw new ArgumentNullException("sortingField");
}
if (sortingOrder == SortOrder.Unspecified)
{
sortingOrder = SortOrder.Ascending;
}
Specification <TAggregateRoot> querySpecification = new AnySpecification <TAggregateRoot>();
if (!string.IsNullOrEmpty(filterExpression))
{
if (expressionArgs != null && expressionArgs.Length > 0)
{
querySpecification =
Specification <TAggregateRoot> .Eval(
DynamicExpression.ParseLambda <TAggregateRoot, bool>(filterExpression, expressionArgs));
}
else
{
querySpecification =
Specification <TAggregateRoot> .Eval(
DynamicExpression.ParseLambda <TAggregateRoot, bool>(filterExpression));
}
}
var sortPredicate = DynamicExpression.ParseLambda <TAggregateRoot, dynamic>(sortingField);
var result = repository.FindAll(querySpecification, sortPredicate, sortingOrder, pageNumber, pageSize);
return(result != null
? result.CastPagedResult <TAggregateRoot, TViewModel>(Mapper.Map <TAggregateRoot, TViewModel>)
: null);
}
public void CanParseAs()
{
var expression = "(resource as System.String).Length";
var parameters = new[]
{
Expression.Parameter(typeof(object), "resource"),
};
var expr = (Expression <Func <object, int> >)DynamicExpression.ParseLambda(parameters, typeof(int), expression);
Console.WriteLine(expr);
Assert.NotNull(expr);
var func = expr.Compile();
Assert.Equal(5, func("hello"));
}
public void CanParseIsUsingBuiltInType()
{
var expression = "resource is Double";
var parameters = new[]
{
Expression.Parameter(typeof(object), "resource"),
};
var expr = (Expression <Func <object, bool> >)DynamicExpression.ParseLambda(parameters, typeof(bool), expression);
Console.WriteLine(expr);
Assert.NotNull(expr);
var func = expr.Compile();
Assert.True(func(2.2));
}
protected static Expression <Func <T, bool> > GenerateExpression(params object[] keys)
{
MemberMapper[] keyList = typeof(T).GetKeyFieldList <T>();
if (keyList.Length == 0)
{
throw new DataAccessException(string.Format("No primary key field(s) in the type '{0}'.", typeof(T).FullName));
}
int n = keys.Length;
string[] expressions = new string[n];
object[] convertKeys = new object[n];
for (int i = 0; i < n; i++)
{
MemberMapper mm = keyList[i];
expressions[i] = string.Format("{0}=@{1}", mm.Name, i);
convertKeys[i] = keys[i].ChangeTypeTo(mm.Type);
}
return(DynamicExpression.ParseLambda <T, bool>(string.Join(" and ", expressions), convertKeys));
}
public void CanParseIs()
{
var expression = "resource is System.String";
var parameters = new[]
{
Expression.Parameter(typeof(object), "resource"),
};
var expr = (Expression <Func <object, bool> >)DynamicExpression.ParseLambda(parameters, typeof(bool), expression);
Console.WriteLine(expr);
Assert.NotNull(expr);
var func = expr.Compile();
Assert.True(func("hello"));
Assert.False(func(2));
}
public void CanParseNestedLambdasWithOuterVariableReference()
{
var expression = "resource.Any(allowed.Contains(it_1.Item1))";
var parameters = new[]
{
Expression.Parameter(typeof(Tuple <string>[]), "resource"),
Expression.Parameter(typeof(string[]), "allowed"),
};
var expr = (Expression <Func <Tuple <string>[], string[], bool> >)DynamicExpression.ParseLambda(parameters, typeof(bool), expression);
Console.WriteLine(expr);
Assert.NotNull(expr);
var func = expr.Compile();
Assert.True(func(new[] { Tuple.Create("1"), Tuple.Create("2") }, new[] { "1", "3" }));
Assert.False(func(new[] { Tuple.Create("1"), Tuple.Create("2") }, new[] { "3" }));
}
private bool SearchTokenTreeForItem(SyntaxToken token, ParameterExpression nodeParam,
ParameterExpression syntaxKindParam, EnumHelper <SyntaxKind, ushort> syntaxKind)
{
var resultForThisToken = false;
var parent = token.Parent;
while (parent != null)
{
var parentExpression =
DynamicExpression.ParseLambda(new[] { nodeParam, syntaxKindParam }, typeof(bool), ParentCondition);
var thisResult = (bool)parentExpression.Compile().DynamicInvoke(parent, syntaxKind);
if (thisResult)
{
resultForThisToken = true;
break;
}
parent = parent.Parent;
}
return(resultForThisToken);
}
protected LambdaExpression GenDefaultActionExpression(string expressionString)
{
return(CodeExpression.ParseLambda(new ParameterExpression[] { GetMethodProviderParameterExpression() }, null, expressionString));
}
public Expression <Func <T, bool> > Or(string expression, params object[] values)
{
var e = DynamicExpression.ParseLambda <T, bool>(expression, values);
return(Or(e));
}
