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);
}
}
