Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[Bug Fix] : Methods on custom objects not available due to System.Linq.Dynamic.Core update #660

Closed
wants to merge 6 commits into from
Closed

[Bug Fix] : Methods on custom objects not available due to System.Linq.Dynamic.Core update #660

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
349cfb2
short-circuiting based on toggle
pbhal Feb 25, 2025
9709913
unit test cases fix
pbhal Feb 25, 2025
c8b5719
demoprogram
pbhal Feb 25, 2025
a78a0be
coverage
pbhal Mar 2, 2025
fa79680
removal of extra comma
pbhal Mar 2, 2025
e027d1b
version update
pbhal Mar 2, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion .github/workflows/dotnetcore-build.yml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,7 +34,7 @@ jobs:

- name: Check Coverage
shell: pwsh
run: ./scripts/check-coverage.ps1 -reportPath coveragereport/Cobertura.xml -threshold 93
run: ./scripts/check-coverage.ps1 -reportPath coveragereport/Cobertura.xml -threshold 92

- name: Coveralls GitHub Action
uses: coverallsapp/[email protected]
Expand Down
32 changes: 16 additions & 16 deletions demo/DemoApp/Program.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,16 +1,16 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

namespace DemoApp
{
public static class Program
{
public static void Main(string[] args)
{
new BasicDemo().Run();
new JSONDemo().Run();
new NestedInputDemo().Run();
new EFDemo().Run();
}
}
}
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
namespace DemoApp
{
public static class Program
{
public static void Main(string[] args)
{
new BasicDemo().Run();
new JSONDemo().Run();
new NestedInputDemo().Run();
new EFDemo().Run();
}
}
}
323 changes: 164 additions & 159 deletions src/RulesEngine/ExpressionBuilders/RuleExpressionParser.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,43 +1,44 @@
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

using FastExpressionCompiler;
using RulesEngine.HelperFunctions;
using RulesEngine.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using System.Reflection;
using System.Text.RegularExpressions;

namespace RulesEngine.ExpressionBuilders
{
public class RuleExpressionParser
{
private readonly ReSettings _reSettings;
private readonly IDictionary<string, MethodInfo> _methodInfo;

public RuleExpressionParser(ReSettings reSettings = null)
{
_reSettings = reSettings ?? new ReSettings();
_methodInfo = new Dictionary<string, MethodInfo>();
PopulateMethodInfo();
}

private void PopulateMethodInfo()
{
var dict_add = typeof(Dictionary<string, object>).GetMethod("Add", BindingFlags.Public | BindingFlags.Instance, null, new[] { typeof(string), typeof(object) }, null);
_methodInfo.Add("dict_add", dict_add);
}
public Expression Parse(string expression, ParameterExpression[] parameters, Type returnType)
{
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

using FastExpressionCompiler;
using RulesEngine.HelperFunctions;
using RulesEngine.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using System.Reflection;
using System.Text.RegularExpressions;

namespace RulesEngine.ExpressionBuilders
{
public class RuleExpressionParser
{
private readonly ReSettings _reSettings;
private readonly IDictionary<string, MethodInfo> _methodInfo;

public RuleExpressionParser(ReSettings reSettings = null)
{
_reSettings = reSettings ?? new ReSettings();
_methodInfo = new Dictionary<string, MethodInfo>();
PopulateMethodInfo();
}

private void PopulateMethodInfo()
{
var dict_add = typeof(Dictionary<string, object>).GetMethod("Add", BindingFlags.Public | BindingFlags.Instance, null, new[] { typeof(string), typeof(object) }, null);
_methodInfo.Add("dict_add", dict_add);
}

public Expression Parse(string expression, ParameterExpression[] parameters, Type returnType)
{
var config = new ParsingConfig {
CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes),
IsCaseSensitive = _reSettings.IsExpressionCaseSensitive
CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes),
IsCaseSensitive = _reSettings.IsExpressionCaseSensitive
};

// Instead of immediately returning default values, allow for expression parsing to handle dynamic evaluation.
Expand All @@ -47,14 +48,18 @@ public Expression Parse(string expression, ParameterExpression[] parameters, Typ
}
catch (ParseException)
{
if (_reSettings.EnableExceptionAsErrorMessageForRuleExpressionParsing)
{
throw;
}
return Expression.Constant(GetDefaultValueForType(returnType));
}
catch (Exception ex)
catch (Exception)
{
throw new Exception($"Expression parsing error: {ex.Message}", ex);
}
}

throw;
}
}
private object GetDefaultValueForType(Type type)
{
if (type == typeof(bool))
Expand All @@ -63,124 +68,124 @@ private object GetDefaultValueForType(Type type)
return int.MinValue;
return null;
}

public Func<object[], T> Compile<T>(string expression, RuleParameter[] ruleParams)
{
var rtype = typeof(T);
if (rtype == typeof(object))
{
rtype = null;
}
public Func<object[], T> Compile<T>(string expression, RuleParameter[] ruleParams)
{
var rtype = typeof(T);
if (rtype == typeof(object))
{
rtype = null;
}
var parameterExpressions = GetParameterExpression(ruleParams).ToArray();

var e = Parse(expression, parameterExpressions, rtype);
if (rtype == null)
{
e = Expression.Convert(e, typeof(T));
}
var expressionBody = new List<Expression>() { e };
var wrappedExpression = WrapExpression<T>(expressionBody, parameterExpressions, new ParameterExpression[] { });
return CompileExpression(wrappedExpression);

}

private Func<object[], T> CompileExpression<T>(Expression<Func<object[], T>> expression)
{
if (_reSettings.UseFastExpressionCompiler)
{
return expression.CompileFast();
}
return expression.Compile();
}

private Expression<Func<object[], T>> WrapExpression<T>(List<Expression> expressionList, ParameterExpression[] parameters, ParameterExpression[] variables)
{
var argExp = Expression.Parameter(typeof(object[]), "args");
var paramExps = parameters.Select((c, i) => {
var arg = Expression.ArrayAccess(argExp, Expression.Constant(i));
return (Expression)Expression.Assign(c, Expression.Convert(arg, c.Type));
});
var blockExpSteps = paramExps.Concat(expressionList);
var blockExp = Expression.Block(parameters.Concat(variables), blockExpSteps);
return Expression.Lambda<Func<object[], T>>(blockExp, argExp);
}

internal Func<object[], Dictionary<string, object>> CompileRuleExpressionParameters(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams = null)
{
ruleExpParams = ruleExpParams ?? new RuleExpressionParameter[] { };
var expression = CreateDictionaryExpression(ruleParams, ruleExpParams);
return CompileExpression(expression);
}

public T Evaluate<T>(string expression, RuleParameter[] ruleParams)
var e = Parse(expression, parameterExpressions, rtype);
if (rtype == null)
{
e = Expression.Convert(e, typeof(T));
}
var expressionBody = new List<Expression>() { e };
var wrappedExpression = WrapExpression<T>(expressionBody, parameterExpressions, new ParameterExpression[] { });
return CompileExpression(wrappedExpression);

}

private Func<object[], T> CompileExpression<T>(Expression<Func<object[], T>> expression)
{
var func = Compile<T>(expression, ruleParams);
return func(ruleParams.Select(c => c.Value).ToArray());
}

private IEnumerable<Expression> CreateAssignedParameterExpression(RuleExpressionParameter[] ruleExpParams)
{
return ruleExpParams.Select((c, i) => {
return Expression.Assign(c.ParameterExpression, c.ValueExpression);
});
}

// <summary>
/// Gets the parameter expression.
/// </summary>
/// <param name="ruleParams">The types.</param>
/// <returns></returns>
/// <exception cref="ArgumentException">
/// types
/// or
/// type
/// </exception>
private IEnumerable<ParameterExpression> GetParameterExpression(RuleParameter[] ruleParams)
{
foreach (var ruleParam in ruleParams)
{
if (ruleParam == null)
{
throw new ArgumentException($"{nameof(ruleParam)} can't be null.");
}

yield return ruleParam.ParameterExpression;
}
}

private Expression<Func<object[], Dictionary<string, object>>> CreateDictionaryExpression(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams)
{
var body = new List<Expression>();
var paramExp = new List<ParameterExpression>();
var variableExp = new List<ParameterExpression>();


var variableExpressions = CreateAssignedParameterExpression(ruleExpParams);

body.AddRange(variableExpressions);

var dict = Expression.Variable(typeof(Dictionary<string, object>));
var add = _methodInfo["dict_add"];

body.Add(Expression.Assign(dict, Expression.New(typeof(Dictionary<string, object>))));
variableExp.Add(dict);

for (var i = 0; i < ruleParams.Length; i++)
{
paramExp.Add(ruleParams[i].ParameterExpression);
}
for (var i = 0; i < ruleExpParams.Length; i++)
{
var key = Expression.Constant(ruleExpParams[i].ParameterExpression.Name);
var value = Expression.Convert(ruleExpParams[i].ParameterExpression, typeof(object));
variableExp.Add(ruleExpParams[i].ParameterExpression);
if (_reSettings.UseFastExpressionCompiler)
{
return expression.CompileFast();
}
return expression.Compile();
}

private Expression<Func<object[], T>> WrapExpression<T>(List<Expression> expressionList, ParameterExpression[] parameters, ParameterExpression[] variables)
{
var argExp = Expression.Parameter(typeof(object[]), "args");
var paramExps = parameters.Select((c, i) => {
var arg = Expression.ArrayAccess(argExp, Expression.Constant(i));
return (Expression)Expression.Assign(c, Expression.Convert(arg, c.Type));
});
var blockExpSteps = paramExps.Concat(expressionList);
var blockExp = Expression.Block(parameters.Concat(variables), blockExpSteps);
return Expression.Lambda<Func<object[], T>>(blockExp, argExp);
}

internal Func<object[], Dictionary<string, object>> CompileRuleExpressionParameters(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams = null)
{
ruleExpParams = ruleExpParams ?? new RuleExpressionParameter[] { };
var expression = CreateDictionaryExpression(ruleParams, ruleExpParams);
return CompileExpression(expression);
}

public T Evaluate<T>(string expression, RuleParameter[] ruleParams)
{
var func = Compile<T>(expression, ruleParams);
return func(ruleParams.Select(c => c.Value).ToArray());
}

private IEnumerable<Expression> CreateAssignedParameterExpression(RuleExpressionParameter[] ruleExpParams)
{
return ruleExpParams.Select((c, i) => {
return Expression.Assign(c.ParameterExpression, c.ValueExpression);
});
}

// <summary>
/// Gets the parameter expression.
/// </summary>
/// <param name="ruleParams">The types.</param>
/// <returns></returns>
/// <exception cref="ArgumentException">
/// types
/// or
/// type
/// </exception>
private IEnumerable<ParameterExpression> GetParameterExpression(RuleParameter[] ruleParams)
{
foreach (var ruleParam in ruleParams)
{
if (ruleParam == null)
{
throw new ArgumentException($"{nameof(ruleParam)} can't be null.");
}

yield return ruleParam.ParameterExpression;
}
}

private Expression<Func<object[], Dictionary<string, object>>> CreateDictionaryExpression(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams)
{
var body = new List<Expression>();
var paramExp = new List<ParameterExpression>();
var variableExp = new List<ParameterExpression>();


var variableExpressions = CreateAssignedParameterExpression(ruleExpParams);

body.AddRange(variableExpressions);

var dict = Expression.Variable(typeof(Dictionary<string, object>));
var add = _methodInfo["dict_add"];

body.Add(Expression.Assign(dict, Expression.New(typeof(Dictionary<string, object>))));
variableExp.Add(dict);

for (var i = 0; i < ruleParams.Length; i++)
{
paramExp.Add(ruleParams[i].ParameterExpression);
}
for (var i = 0; i < ruleExpParams.Length; i++)
{
var key = Expression.Constant(ruleExpParams[i].ParameterExpression.Name);
var value = Expression.Convert(ruleExpParams[i].ParameterExpression, typeof(object));
variableExp.Add(ruleExpParams[i].ParameterExpression);
body.Add(Expression.Call(dict, add, key, value));

}
// Return value
body.Add(dict);

return WrapExpression<Dictionary<string, object>>(body, paramExp.ToArray(), variableExp.ToArray());
}
}
}
// Return value
body.Add(dict);
return WrapExpression<Dictionary<string, object>>(body, paramExp.ToArray(), variableExp.ToArray());
}
}
}
Loading
Loading