public static string FindPropertyExpression(Expression expression, ParameterOption option)
{
string memberExpression = FindMemberExpression(expression, option);
int periodPosition = memberExpression.LastIndexOf('.') + 1;
string property = (periodPosition <= 0) ? memberExpression : memberExpression.Substring(periodPosition);
return property;
}
public static CriteriaOperator FindMemberOperator(Expression expression, ParameterOption option)
{
if (!IsMemberExpression(expression))
return new OperandValue(FindValue(expression));
if (expression is UnaryExpression)
{
UnaryExpression unaryExpression = (UnaryExpression)expression;
if (unaryExpression.NodeType != ExpressionType.Convert)
throw new Exception("Cannot interpret member from " + expression.ToString());
return FindMemberOperator(unaryExpression.Operand, option);
}
return new OperandProperty(FindMemberExpression(expression, option));
}
public static string FindPropertyExpression(Expression expression)
{
ParameterOption option = new ParameterOption();
return FindPropertyExpression(expression, option);
}
private static CriteriaOperator ProcessVisualBasicStringComparison(BinaryExpression be, ParameterOption option)
{
var methodCall = (MethodCallExpression)be.Left;
if (IsMemberExpression(methodCall.Arguments[1]))
return ProcessMemberExpression(methodCall.Arguments[0], methodCall.Arguments[1], be.NodeType, option);
else
return ProcessSimpleExpression(methodCall.Arguments[0], methodCall.Arguments[1], be.NodeType, option);
}
private static CriteriaOperator ProcessSimpleExpression(Expression left, Expression right, ExpressionType nodeType, ParameterOption option)
{
CriteriaOperator property = FindMemberOperator(left, option);
System.Type propertyType = FindMemberType(left);
object value = FindValue(right);
value = ConvertType(value, propertyType);
return new BinaryOperator(property, new OperandValue(value), GetBinaryType(nodeType));
}
private static CriteriaOperator ProcessSimpleExpression(BinaryExpression be, ParameterOption option)
{
if (be.Left.NodeType == ExpressionType.Call && ((MethodCallExpression)be.Left).Method.Name == "CompareString")
return ProcessVisualBasicStringComparison(be, option);
return ProcessSimpleExpression(be.Left, be.Right, be.NodeType, option);
}
private static CriteriaOperator ProcessOrExpression(BinaryExpression expression, ParameterOption option)
{
return new GroupOperator(GroupOperatorType.Or, ProcessExpression(expression.Left, option), ProcessExpression(expression.Right, option));
}
private static string FindMemberExpression(Expression expression, ParameterOption option)
{
if (expression is MemberExpression)
{
MemberExpression memberExpression = (MemberExpression)expression;
if (memberExpression.Expression.NodeType == ExpressionType.MemberAccess
|| memberExpression.Expression.NodeType == ExpressionType.Call)
{
if (IsNullableOfT(memberExpression.Member.DeclaringType))
{
// it's a Nullable<T>, so ignore any .Value
if (memberExpression.Member.Name == "Value")
return FindMemberExpression(memberExpression.Expression, new ParameterOption());
}
return FindMemberExpression(memberExpression.Expression, new ParameterOption()) + "." + memberExpression.Member.Name;
//return FindMemberExpression(memberExpression.Expression, option) + "." + memberExpression.Member.Name;
}
else if (memberExpression.Expression.NodeType == ExpressionType.Convert)
{
return (FindMemberExpression(memberExpression.Expression, new ParameterOption()) + "." + memberExpression.Member.Name).TrimStart('.');
}
else if (option.WithParameter)
{
if (option.TypeFormat.ContainsKey(memberExpression.Expression.Type))
return option.TypeFormat[memberExpression.Expression.Type].FormatArgs(memberExpression.Member.Name);
return (memberExpression.Expression + "." + memberExpression.Member.Name).TrimStart('.');
}
else
{
return memberExpression.Member.Name;
}
}
if (expression is UnaryExpression)
{
UnaryExpression unaryExpression = (UnaryExpression)expression;
if (unaryExpression.NodeType != ExpressionType.Convert)
throw new Exception("Cannot interpret member from " + expression.ToString());
return FindMemberExpression(unaryExpression.Operand, option);
}
if (expression is MethodCallExpression)
{
MethodCallExpression methodCallExpression = (MethodCallExpression)expression;
if (methodCallExpression.Method.Name == "GetType")
return ClassMember(methodCallExpression.Object, option);
if (methodCallExpression.Method.Name == "get_Item")
return FindMemberExpression(methodCallExpression.Object, option);
if (methodCallExpression.Method.Name == "First")
return FindMemberExpression(methodCallExpression.Arguments[0], option);
throw new Exception("Unrecognised method call in expression " + expression.ToString());
}
if (expression is ParameterExpression)
return "";
throw new Exception("Could not determine member from " + expression.ToString());
}
public static CriteriaOperator FindMemberOperator(Expression expression)
{
ParameterOption option = new ParameterOption();
return FindMemberOperator(expression, option);
}
private static CriteriaOperator ProcessMemberExpression(Expression left, Expression right, ExpressionType nodeType, ParameterOption option)
{
CriteriaOperator leftProperty = FindMemberOperator(left, option);
CriteriaOperator rightProperty = FindMemberOperator(right, option);
return new BinaryOperator(leftProperty, rightProperty, GetBinaryType(nodeType));
}
private static CriteriaOperator ProcessMemberExpression(BinaryExpression be, ParameterOption option)
{
return ProcessMemberExpression(be.Left, be.Right, be.NodeType, option);
}
private static CriteriaOperator ProcessExpression(Expression expression, ParameterOption option)
{
if (expression is NewArrayExpression)
return ProcessNewArrayExpression((NewArrayExpression)expression, option);
if (expression is BinaryExpression)
return ProcessBinaryExpression((BinaryExpression)expression, option);
return ProcessBooleanExpression((Expression)expression, option);
}
private static CriteriaOperator ProcessBooleanExpression(Expression expression, ParameterOption option)
{
if (expression is MemberExpression)
{
return new BinaryOperator(FindMemberExpression(expression, option), true);
}
if (expression is UnaryExpression)
{
UnaryExpression unaryExpression = (UnaryExpression)expression;
if (unaryExpression.NodeType != ExpressionType.Not)
throw new Exception("Cannot interpret member from " + expression.ToString());
if (IsMemberExpression(unaryExpression.Operand))
return new BinaryOperator(FindMemberExpression(unaryExpression.Operand, option), false);
else
return ProcessExpression(unaryExpression.Operand, option).Not();
}
var methodCallExpression = expression as MethodCallExpression;
if (methodCallExpression != null)
{
return ProcessCustomMethodCall(methodCallExpression);
}
if (expression is TypeBinaryExpression)
{
TypeBinaryExpression typeBinaryExpression = (TypeBinaryExpression)expression;
return new BinaryOperator(ClassMember(typeBinaryExpression.Expression, option), typeBinaryExpression.TypeOperand.FullName);
}
throw new Exception("Could not determine member type from " + expression.NodeType + ", " + expression.ToString() + ", " + expression.GetType());
}
private static CriteriaOperator ProcessBinaryExpression(BinaryExpression expression, ParameterOption option)
{
switch (expression.NodeType)
{
case ExpressionType.AndAlso:
return ProcessAndExpression(expression, option);
case ExpressionType.OrElse:
return ProcessOrExpression(expression, option);
case ExpressionType.Equal:
case ExpressionType.NotEqual:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
if (IsMemberExpression(expression.Right))
return ProcessMemberExpression(expression, option);
else
return ProcessSimpleExpression(expression, option);
default:
throw new Exception("Unhandled binary expression: " + expression.NodeType + ", " + expression.ToString());
}
}
private static CriteriaOperator ProcessNewArrayExpression(NewArrayExpression newArrayExpression, ParameterOption option)
{
var criteria = new GroupOperator(GroupOperatorType.Or);
foreach (var e in newArrayExpression.Expressions)
criteria.Operands.Add(FindMemberOperator(e, option));
return criteria;
}
public static CriteriaOperator ProcessLambdaExpression(LambdaExpression expression, bool withParameter = false)
{
ParameterOption option = new ParameterOption();
option.WithParameter = withParameter;
option.TypeFormat = new Dictionary<Type, string>();
if (withParameter && expression.Parameters.Count > 0)
{
var p = expression.Parameters[0];
option.TypeFormat.Add(p.Type, "domain.{0}");
}
return ProcessExpression(expression.Body, option);
}
private static string ClassMember(Expression expression, ParameterOption option)
{
if (expression.NodeType == ExpressionType.MemberAccess)
return FindMemberExpression(expression, option) + ".class";
else
return "class";
}
