public void EvalDictionaryParams2() { object CreateDicParameter(string name) => new Dictionary <string, object> { { "Name", new Dictionary <string, object> { { "FirstName", name } } } }; var config = new ParsingConfig() { CustomTypeProvider = new DefaultDynamicLinqCustomTypeProvider() }; var parType = new Dictionary <string, object>().GetType(); var lambda = DynamicExpressionParser.ParseLambda(config, new [] { Expression.Parameter(parType, "item") }, typeof(object), "item.Name.FirstName").Compile(); lambda.DynamicInvoke(CreateDicParameter("Julio")).Should().Be("Julio"); lambda.DynamicInvoke(CreateDicParameter("John")).Should().Be("John"); }
public void DynamicExpressionParser_ParseLambda_4_Issue58() { var expressionParams = new[] { Expression.Parameter(typeof(MyClass), "myObj") }; var myClassInstance = new MyClass(); var invokersMerge = new List <object> { myClassInstance }; LambdaExpression expression = DynamicExpressionParser.ParseLambda(false, expressionParams, null, "myObj.Foo()"); Delegate del = expression.Compile(); object result = del.DynamicInvoke(invokersMerge.ToArray()); Check.That(result).Equals(42); }
public void DynamicExpressionParser_ParseLambda_StringLiteral_Backslash() { // Assign string expectedRightValue = "0"; //Act var expression = DynamicExpressionParser.ParseLambda( new[] { Expression.Parameter(typeof(string), "Property1") }, typeof(Boolean), string.Format("{0} >= {1}", "Property1.IndexOf(\"\\\\\")", expectedRightValue)); string leftValue = ((BinaryExpression)expression.Body).Left.ToString(); string rightValue = ((BinaryExpression)expression.Body).Right.ToString(); // Assert Assert.Equal(typeof(Boolean), expression.Body.Type); Assert.Equal("Property1.IndexOf(\"\\\")", leftValue); Assert.Equal(expectedRightValue, rightValue); }
/// <summary> /// Copies common validation rules from <typeparamref name="TEntity"/> type over to corresponding <typeparamref name="TModel"/> type. /// Common rules are: Required and MaxLength rules on string properties (either fluently mapped or annotated). /// </summary> /// <typeparam name="TEntity">The type of source entity.</typeparam> /// <param name="db">The data context instance to which <typeparamref name="TEntity"/> belongs.</param> /// <param name="ignoreProperties">An optional list of property names to ignore.</param> protected virtual void CopyFromEntityRules <TEntity>(DbContext db, params string[] ignoreProperties) where TEntity : BaseEntity, new() { Guard.NotNull(db, nameof(db)); var entityType = db.Model.GetEntityTypes(typeof(TEntity)).FirstOrDefault(); if (entityType != null) { // Get all model properties var modelProps = FastProperty.GetProperties(typeof(TModel), PropertyCachingStrategy.EagerCached); // Get all entity properties not in exclusion list var entityProps = entityType.GetProperties() .Where(x => x.ClrType == typeof(string) && !ignoreProperties.Contains(x.Name)) .OfType <IMutableProperty>(); // Loop thru all entity string properties foreach (var entityProp in entityProps) { // Check if target model contains property (must be of same name and type) if (modelProps.TryGetValue(entityProp.Name, out var modelProp) && modelProp.Property.PropertyType == typeof(string)) { var isNullable = entityProp.IsNullable; var maxLength = entityProp.GetMaxLength(); if (!isNullable || maxLength.HasValue) { var expression = DynamicExpressionParser.ParseLambda <TModel, string>(null, false, "@" + modelProp.Name); if (!isNullable) { RuleFor(expression).NotEmpty(); } if (maxLength.HasValue) { RuleFor(expression).Length(0, maxLength.Value); } } } } } }
public void DynamicExpressionParser_ParseLambda_CustomMethod() { // Assign var config = new ParsingConfig { CustomTypeProvider = new TestCustomTypeProvider() }; var context = new CustomClassWithStaticMethod(); string expression = $"{nameof(CustomClassWithStaticMethod)}.{nameof(CustomClassWithStaticMethod.GetAge)}(10)"; // Act var lambdaExpression = DynamicExpressionParser.ParseLambda(config, typeof(CustomClassWithStaticMethod), null, expression); Delegate del = lambdaExpression.Compile(); int result = (int)del.DynamicInvoke(context); // Assert Check.That(result).IsEqualTo(10); }
public void ParseLambda_ToList() { // Arrange var testList = User.GenerateSampleModels(51); var qry = testList.AsQueryable(); // Act string query = "OrderBy(gg => gg.Income).ToList()"; LambdaExpression expression = DynamicExpressionParser.ParseLambda(qry.GetType(), null, query); Delegate del = expression.Compile(); IEnumerable <dynamic> result = del.DynamicInvoke(qry) as IEnumerable <dynamic>; var expected = qry.OrderBy(gg => gg.Income).ToList(); // Assert Check.That(result).IsNotNull(); Check.That(result).HasSize(expected.Count); Check.That(result.ToArray()[0]).Equals(expected[0]); }
private object Eval(string expression, Parameter[] pars) { if (!_lambdaCache.TryGetValue(expression, out var lambda)) { var parameters = pars.Select(p => p.ParameterExpression).ToArray(); try { lambda = DynamicExpressionParser.ParseLambda(parameters, typeof(object), expression, _variables).Compile(); } catch (ArgumentException) { return(null); } _lambdaCache.Add(expression, lambda); } return(lambda.DynamicInvoke(pars.Select(p => p.Value).ToArray())); }
//public async Task<List<Comment_Board>> GetDataListAsync(Pagination pagination, string condition, string keyword) //{ // var q = GetIQueryable(); // var where = LinqHelper.True<Comment_Board>(); // //筛选 // if (!condition.IsNullOrEmpty() && !keyword.IsNullOrEmpty()) // { // var newWhere = DynamicExpressionParser.ParseLambda<Comment_Board, bool>( // ParsingConfig.Default, false, $@"{condition}.Contains(@0)", keyword); // where = where.And(newWhere); // } // return await q.Where(where).GetPagination(pagination).ToListAsync(); //} public async Task <List <Comment_BoardDTO> > GetDataListAsync(Pagination pagination, string condition, string keyword) { Expression <Func <Comment_Board, Data_User, Comment_BoardDTO> > select = (a, b) => new Comment_BoardDTO { Id = a.Id, ParentId = a.CommentPID, CommentInfo = a.CommentInfo, Supports = a.Supports.GetValueOrDefault(), UserID = b.Id, UserName = b.UserName, CreateTime = a.CreateTime }; //select = select.BuildExtendSelectExpre(); var where = LinqHelper.True <Comment_Board>(); //筛选 if (!condition.IsNullOrEmpty() && !keyword.IsNullOrEmpty()) { var newWhere = DynamicExpressionParser.ParseLambda <Comment_Board, bool>( ParsingConfig.Default, false, $@"{condition}.Contains(@0)", keyword); where = where.And(newWhere); } var q = GetIQueryable().Where(where).AsExpandable(); var userlist = await Service.GetIQueryable <Data_User>().ToListAsync(); var treeList = from a in q join b in userlist on a.UserID equals b.Id into a_b from ab in a_b.DefaultIfEmpty() select @select.Invoke(a, ab); //var treeList =q.Select(x => new Comment_BoardDTO //{ // Id = x.Id, // ParentId = x.CommentPID, // CommentInfo = x.CommentInfo, // Supports = x.Supports // //UserNmae = userapp.GetEntity(x.Id).UserName //}).ToList(); return(TreeHelper.BuildTree(treeList.ToList())); }
/// <summary> /// Expands <see cref="TeamProject"/> property values in a string. /// </summary> /// <param name="target">The <see cref="string"/> where to expand property values in.</param> /// <param name="teamProject">The <see cref="TeamProject"/> instance which property values should be added to the <paramref name="target"/>.</param> /// <returns>The <see cref="string"/> which contains expanded property values.</returns> /// <exception cref="ArgumentNullException">The <paramref name="target"/> or <paramref name="teamProject"/> is null.</exception> public static string Expand(this string target, TeamProject teamProject) { if (target == null) { throw new ArgumentNullException(nameof(target)); } if (teamProject == null) { throw new ArgumentNullException(nameof(teamProject)); } return(Regex.Replace(target, @"{(?<exp>[^}]+)}", match => { var p = Expression.Parameter(typeof(TeamProject), "teamProject"); var e = DynamicExpressionParser.ParseLambda(new[] { p }, null, match.Groups["exp"].Value); return (e.Compile().DynamicInvoke(teamProject) ?? string.Empty).ToString(); })); }
private void AttachOutputs(StepSourceV1 source, Type dataType, Type stepType, WorkflowStep step) { foreach (var output in source.Outputs) { var stepParameter = Expression.Parameter(stepType, "step"); var sourceExpr = DynamicExpressionParser.ParseLambda(new[] { stepParameter }, typeof(object), output.Value); var dataParameter = Expression.Parameter(dataType, "data"); if (output.Key.Contains(".") || output.Key.Contains("[")) { AttachNestedOutput(output, step, source, sourceExpr, dataParameter); } else { AttachDirectlyOutput(output, step, dataType, sourceExpr, dataParameter); } } }
public void DynamicExpressionParser_ParseLambda_ActionDelegate_VoidMethodCallExpression() { // Arrange var dataSource = new MyClass(); var expressionText = "it.Bar()"; var parsingConfig = new ParsingConfig { CustomTypeProvider = new MyClassCustomTypeProvider() }; dataSource.Name.Should().BeNull(); // Act LambdaExpression expression = DynamicExpressionParser.ParseLambda(typeof(Action <MyClass>), parsingConfig, dataSource.GetType(), null, expressionText); Delegate del = expression.Compile(); del.DynamicInvoke(dataSource); // Assert dataSource.Name.Should().NotBeNullOrEmpty(); }
public void Test_DynamicIndexCall() { { object CreateDicParameter(string name) => new Dictionary <string, object> { { "Name", new Dictionary <string, object> { { "FirstName", name }, { "LastName", name + "Test" } } }, }; var parType = new Dictionary <string, object>().GetType(); var lambda = DynamicExpressionParser.ParseLambda(new[] { Expression.Parameter(parType, "item") }, typeof(object), "item.Name.FirstName + \"7\" + item.Name.LastName ").Compile(); var x1 = lambda.DynamicInvoke(CreateDicParameter("Julio")); var x2 = lambda.DynamicInvoke(CreateDicParameter("John")); Check.That(x1).IsEqualTo("Julio7JulioTest"); Check.That(x2).IsEqualTo("John7JohnTest"); } }
public void CreateClass_ShouldBeThreadSafe() { // Arrange const int numOfTasks = 15; var properties = new[] { new DynamicProperty("prop1", typeof(string)) }; var tasks = new List <Task>(numOfTasks); // Act for (var i = 0; i < numOfTasks; i++) { tasks.Add(Task.Run(() => DynamicExpressionParser.CreateClass(properties))); } // Assert Assert.IsTrue(tasks.Any()); Task.WaitAll(tasks.ToArray()); }
public void ParseLambda_Select_2() { // Arrange var testList = User.GenerateSampleModels(5); var qry = testList.AsQueryable(); var externals = new Dictionary <string, object> { { "Users", qry } }; // Act string query = "Users.Select(j => j)"; LambdaExpression expression = DynamicExpressionParser.ParseLambda(null, query, externals); Delegate del = expression.Compile(); object result = del.DynamicInvoke(); // Assert Assert.NotNull(result); }
public Func <TEntity, bool> ParserRule(RuleEngineContext.RuleEngineContext contex, string ruleExpression) { IPlaceHolderParser <TEntity> placeHolderParser = RuleExpressionParserFactory.CreatePalceHolderParser <TEntity>(); placeHolderParser.AddPlaceHolders(_placeholders); var strexpression = placeHolderParser.ParsePlaceHolder(contex, ruleExpression); try { var expression = DynamicExpressionParser. ParseLambda <TEntity, bool>(contex.EntityContextMetadata.GetRuleParserConfig(), true, strexpression); return(expression.Compile()); } catch (Exception ex) { throw new ExpressionParserException("StringRuleExpressionParser", ruleExpression, strexpression, contex.RuleEngineId, ex); } }
public void DynamicExpressionParser_ParseLambda_UseParameterizedNamesInDynamicQuery_true() { // Assign var config = new ParsingConfig { UseParameterizedNamesInDynamicQuery = true }; // Act var expression = DynamicExpressionParser.ParseLambda <string, bool>(config, true, "s => s == \"x\""); // Assert dynamic constantExpression = ((MemberExpression)(expression.Body as BinaryExpression).Right).Expression as ConstantExpression; dynamic wrappedObj = constantExpression.Value; var propertyInfo = wrappedObj.GetType().GetProperty("Value", BindingFlags.Instance | BindingFlags.Public); string value = propertyInfo.GetValue(wrappedObj) as string; Check.That(value).IsEqualTo("x"); }
public void DynamicExpressionParser_ParseLambda_With_Null_Equals_Guid() { // Arrange var user = new User(); Guid guidEmpty = Guid.Empty; Guid someId = Guid.NewGuid(); string expressionText = $"iif(null == @0.Id, @0.Id == Guid.Parse(\"{someId}\"), Id == Id)"; // Act var lambda = DynamicExpressionParser.ParseLambda(typeof(User), null, expressionText, user); var boolLambda = lambda as Expression <Func <User, bool> >; Assert.NotNull(boolLambda); var del = lambda.Compile(); bool result = (bool)del.DynamicInvoke(user); // Assert Assert.True(result); }
public static dynamic GroupByMany <TElement>(this IEnumerable <TElement> elements, IEnumerable <Group> groupSelectors) { //create a new list of Kendo Group Selectors var selectors = new List <GroupSelector <TElement> >(groupSelectors.Count()); foreach (var selector in groupSelectors) { //compile the Dynamic Expression Lambda for each one var expression = DynamicExpressionParser.ParseLambda(false, typeof(TElement), typeof(object), selector.Field); //add it to the list selectors.Add(new GroupSelector <TElement> { Selector = (Func <TElement, object>)expression.Compile(), Field = selector.Field, Aggregates = selector.Aggregates }); } //call the actual group by method return(elements.GroupByMany(selectors.ToArray())); }
public void ExpressionParseTest() { var customers = new Customer[] { new Customer { Id = 1, Name = "Customer1" }, new Customer { Id = 2, Name = "Customer2" } }.AsEnumerable(); string query = "customers.Where(c => c.Id == 1).OrderBy(c=> c.Name)"; var lambda = DynamicExpressionParser.ParseLambda(new [] { Expression.Parameter(customers.GetType(), "customers") }, null, query); var dlg = lambda.Compile(); dlg.DynamicInvoke(customers).Should().BeAssignableTo <IEnumerable <Customer> >(); ((IEnumerable <Customer>)dlg.DynamicInvoke(customers)).Should().HaveCount(1); ((IEnumerable <Customer>)dlg.DynamicInvoke(customers)).First().Id.Should().Be(1); }
internal override Expression <Func <RuleInput, RuleResultTree> > BuildExpressionForRule(Rule rule, IEnumerable <ParameterExpression> typeParamExpressions, ParameterExpression ruleInputExp) { try { var config = new ParsingConfig { CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes) }; var e = DynamicExpressionParser.ParseLambda(config, typeParamExpressions.ToArray(), null, rule.Expression); var body = e.Body is BinaryExpression binaryExpression ? binaryExpression : Expression.MakeBinary(ExpressionType.And, e.Body, Expression.Constant(true)); return(Helpers.ToResultTreeExpression(rule, null, body, typeParamExpressions, ruleInputExp)); } catch (Exception ex) { var binaryExpression = Expression.And(Expression.Constant(true), Expression.Constant(false)); var exceptionMessage = ex.Message; return(Helpers.ToResultTreeExpression(rule, null, binaryExpression, typeParamExpressions, ruleInputExp, exceptionMessage)); } }
public Task ApplyAsync(EntityRuleContext context) { var entityType = context.Entity.GetType(); var entityRuleName = RuleNameAttribute.GetRuleName(entityType); IEnumerable <IRuleSet> groupRuleSets = new List <IRuleSet>(); groupRuleSets = Repository.GetRuleSets(context.Groups); var sessionFactory = Repository.Compile(context.Groups); var session = sessionFactory.CreateSession(); session.Insert(context.Entity); session.Fire(); foreach (var groupRuleSet in groupRuleSets) { } foreach (var group in context.Groups) { var groupRuleSet = new RuleSet(group.Name); Repository.GetRuleSet(group.Name); foreach (var rule in group.Rules) { var builder = new RuleBuilder(); builder.Name(rule.Name); PatternBuilder thisRulePattern = builder.LeftHandSide().Pattern(entityType, entityRuleName); ParameterExpression thisRuleParameter = thisRulePattern.Declaration.ToParameterExpression(); var ruleCondition = Expression.Lambda(DynamicExpressionParser.ParseLambda(typeof(bool), rule.Expression), thisRuleParameter); thisRulePattern.Condition(ruleCondition); } } throw new NotImplementedException(); }
public void ReturnsWhetherSuchEntityExists(bool expected, string predicateStr) { // Arrange var predicate = DynamicExpressionParser.ParseLambda <Test, bool>(new ParsingConfig() { }, true, predicateStr); var mapperMock = new Mock <IMapper>(); var repositoryMock = new Mock <IDeletableEntityRepository <Test> >(); repositoryMock.Setup(x => x.AllAsNoTracking()) .Returns(GetTestData()); var baseService = new BaseService <Test>(repositoryMock.Object, mapperMock.Object); // Act var actual = baseService.Exists(predicate); // Assert Assert.Equal(expected, actual); }
public void ParseLambda_Complex_2() { // Arrange var testList = User.GenerateSampleModels(51); var qry = testList.AsQueryable(); // Act string query = "GroupBy(x => new { x.Profile.Age }, it).OrderBy(gg => gg.Key.Age).Select(j => new (j.Key.Age, j.Sum(k => k.Income) As TotalIncome))"; LambdaExpression expression = DynamicExpressionParser.ParseLambda(qry.GetType(), null, query); Delegate del = expression.Compile(); IEnumerable <dynamic> result = del.DynamicInvoke(qry) as IEnumerable <dynamic>; var expected = qry.GroupBy(x => new { x.Profile.Age }, x => x).OrderBy(gg => gg.Key.Age).Select(j => new { j.Key.Age, TotalIncome = j.Sum(k => k.Income) }).Select(c => new ComplexParseLambda1Result { Age = c.Age, TotalIncome = c.TotalIncome }).Cast <dynamic>().ToArray(); // Assert Check.That(result).IsNotNull(); Check.That(result).HasSize(expected.Length); Check.That(result.ToArray()[0]).Equals(expected[0]); }
internal override RuleFunc <RuleResultTree> BuildExpressionForRule(Rule rule, IEnumerable <ParameterExpression> typeParamExpressions) { try { var config = new ParsingConfig { CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes) }; var e = DynamicExpressionParser.ParseLambda(config, true, typeParamExpressions.ToArray(), typeof(bool), rule.Expression); var ruleDelegate = e.Compile(); bool func(object[] paramList) => (bool)ruleDelegate.DynamicInvoke(paramList); return(Helpers.ToResultTree(rule, null, func)); } catch (Exception ex) { bool func(object[] param) => false; var exceptionMessage = ex.Message; return(Helpers.ToResultTree(rule, null, func, exceptionMessage)); } }
private static Action <IStepBody, object, IStepExecutionContext> BuildScalarInputAction(KeyValuePair <string, object> input, ParameterExpression dataParameter, ParameterExpression contextParameter, ParameterExpression environmentVarsParameter, PropertyInfo stepProperty) { var expr = System.Convert.ToString(input.Value); var sourceExpr = DynamicExpressionParser.ParseLambda(new[] { dataParameter, contextParameter, environmentVarsParameter }, typeof(object), expr); void acn(IStepBody pStep, object pData, IStepExecutionContext pContext) { object resolvedValue = sourceExpr.Compile().DynamicInvoke(pData, pContext, Environment.GetEnvironmentVariables()); if (stepProperty.PropertyType.IsEnum) { stepProperty.SetValue(pStep, Enum.Parse(stepProperty.PropertyType, (string)resolvedValue, true)); } else { stepProperty.SetValue(pStep, System.Convert.ChangeType(resolvedValue, stepProperty.PropertyType)); } } return(acn); }
public void DoesntFindTheEnitityAndReturnsNull(string predicateStr) { // Arrange var predicate = DynamicExpressionParser.ParseLambda <Test, bool>(new ParsingConfig() { }, true, predicateStr); AutoMapperConfig.RegisterMappings(typeof(Test).Assembly, typeof(ErrorViewModel).Assembly); var repositoryMock = new Mock <IDeletableEntityRepository <Test> >(); repositoryMock.Setup(x => x.AllAsNoTracking()) .Returns(GetTestData()); var baseService = new BaseService <Test>(repositoryMock.Object, AutoMapperConfig.MapperInstance); // Act var test = baseService.GetSingle <TestViewModel>(predicate); // Assert Assert.Null(test); }
private void AttachOutcomes(StepSourceV1 source, Type dataType, WorkflowStep step) { if (!string.IsNullOrEmpty(source.NextStepId)) { step.Outcomes.Add(new StepOutcome() { ExternalNextStepId = $"{source.NextStepId}" }); } foreach (var nextStep in source.OutcomeSteps) { var dataParameter = Expression.Parameter(dataType, "data"); var sourceExpr = DynamicExpressionParser.ParseLambda(new[] { dataParameter }, typeof(object), nextStep.Value); step.Outcomes.Add(new StepOutcome() { Value = sourceExpr, ExternalNextStepId = $"{nextStep.Key}" }); } }
public void DynamicExpressionParser_ParseLambda_WithStructWithEquality() { // Assign var testList = User.GenerateSampleModels(51); var qry = testList.AsQueryable(); // Act ulong expectedX = (ulong)long.MaxValue + 3; string query = $"Where(x => x.SnowflakeId == {expectedX})"; LambdaExpression expression = DynamicExpressionParser.ParseLambda(qry.GetType(), null, query); Delegate del = expression.Compile(); IEnumerable <dynamic> result = del.DynamicInvoke(qry) as IEnumerable <dynamic>; var expected = qry.Where(gg => gg.SnowflakeId == new SnowflakeId(expectedX)).ToList(); // Assert Check.That(result).IsNotNull(); Check.That(result).HasSize(expected.Count); Check.That(result.ToArray()[0]).Equals(expected[0]); }
public void CompleteTest( string firstExpectedName, int firstExpectedCount, string secondExpectedName, int secondExpectedCount, int expectedCountEntities, string predicateStr, string orderByStr, bool asc, int skip, int take) { // Arrange var predicate = DynamicExpressionParser.ParseLambda <Test, bool>(new ParsingConfig() { }, true, predicateStr); var orderBy = DynamicExpressionParser.ParseLambda <Test, object>(new ParsingConfig() { }, true, orderByStr); var testData = GetTestData(); AutoMapperConfig.RegisterMappings(typeof(Test).Assembly, typeof(ErrorViewModel).Assembly); var repositoryMock = new Mock <IDeletableEntityRepository <Test> >(); repositoryMock.Setup(x => x.AllAsNoTracking()) .Returns(testData); var baseService = new BaseService <Test>(repositoryMock.Object, AutoMapperConfig.MapperInstance); // Act var tests = baseService.GetMany <TestViewModel>(predicate, orderBy, asc, skip, take).ToList(); // Assert Assert.Equal(firstExpectedName, tests[0].Name); Assert.Equal(firstExpectedCount, tests[0].Count); Assert.Equal(secondExpectedName, tests[1].Name); Assert.Equal(secondExpectedCount, tests[1].Count); Assert.Equal(expectedCountEntities, tests.Count); }
public Delegate ParseGroupString(RuleEngineContext.RuleEngineContext contex, string placeHolderExpression) { IPlaceHolderParser <TEntity> placeHolderParser = RuleExpressionParserFactory.CreatePalceHolderParser <TEntity>(); placeHolderParser.AddPlaceHolders(_placeholders); string[] expressions = placeHolderExpression.Split(','); int propertyCounter = 1; PlaceHolderTextParser place = new PlaceHolderTextParser(placeHolderExpression); List <string> lstExpressions = new List <string>(); foreach (var expr in expressions) { try { string parsedExpression = placeHolderParser.ParsePlaceHolder(contex, string.Format("({0}) as Prop{1}", expr, propertyCounter)); lstExpressions.Add(parsedExpression); propertyCounter = propertyCounter + 1; } catch (System.Exception ex) { throw new ExpressionParserException("GroupKeyExpressionParser", placeHolderExpression, contex.RuleEngineId, ex); } } var inputExpression = string.Format("new ({0})", string.Join(",", lstExpressions)); try { var lamdaexpr = DynamicExpressionParser .ParseLambda(contex.EntityContextMetadata.GetRuleParserConfig(), true, typeof(TEntity), null, inputExpression); return(lamdaexpr.Compile()); } catch (Exception ex) { throw new ExpressionParserException("GroupKeyExpressionParser", placeHolderExpression, inputExpression, contex.RuleEngineId, ex); } }