|
public static MakeUnary ( ExpressionType unaryType, |
||
| unaryType | ExpressionType | The |
| operand | An |
|
| type | Type | The |
| return | ||
public void Typed(Linq.ExpressionType expression, Type type = null)
{
var operandType = typeof(object);
type ??= operandType;
var expected = LinqExpression.MakeUnary(expression, LinqExpression.Parameter(operandType), type);
var actual = $@"
@prefix : <http://example.com/> .
@prefix xt: <http://example.com/ExpressionTypes/> .
:s
:unaryExpressionType xt:{expression} ;
:unaryOperand [
:parameterType [
:typeName ""{operandType}"" ;
] ;
] ;
:unaryType [
:typeName ""{type}"" ;
] ;
.
";
ShouldBe(actual, expected);
}
public void Quote()
{
var expected = LinqExpression.MakeUnary(Linq.ExpressionType.Quote, LinqExpression.Lambda(LinqExpression.Constant(0L)), null);
var actual = $@"
@prefix : <http://example.com/> .
@prefix xt: <http://example.com/ExpressionTypes/> .
:s
:unaryExpressionType xt:Quote ;
:unaryOperand [
:lambdaBody [
:constantValue 0 ;
] ;
] ;
.
";
ShouldBe(actual, expected);
}
private static Expression sAdd([NotNull] BinaryExpression b)
{
var l = b.Left as ConstantExpression;
var r = b.Right as ConstantExpression;
if (l is null && r is null)
{
return(b);
}
if (l != null && r != null)
{
return(b.NodeType == ExpressionType.Add
? Expression.Constant((double)l.Value + (double)r.Value)
: Expression.Constant((double)l.Value - (double)r.Value));
}
if (l != null && l.Value.Equals(0.0))
{
return(b.NodeType == ExpressionType.Add
? b.Right
: Expression.MakeUnary(ExpressionType.Negate, b.Right, b.Right.Type));
}
return(r != null && r.Value.Equals(0.0) ? b.Left : b);
}
protected override Expression VisitConditional(ConditionalExpression node)
{
Trace(MethodBase.GetCurrentMethod(), node);
var testConstant = node.Test as ConstantExpression;
if (testConstant != null)
{
// If this is a constant expression, evaluate it and visit the appropriate expression
if (testConstant.Value is bool && (bool)testConstant.Value)
{
return(base.Visit(node.IfTrue));
}
return(base.Visit(node.IfFalse));
}
// Transform the node into a binary expression like this:
// A ? B : C = (A && B) || (!A && C)
Expression transformed;
try
{
var left = Expression.MakeBinary(ExpressionType.AndAlso, node.Test, node.IfTrue);
var right = Expression.MakeBinary(ExpressionType.AndAlso,
Expression.MakeUnary(ExpressionType.Not, node.Test, null), node.IfFalse);
transformed = Expression.MakeBinary(ExpressionType.OrElse, left, right);
}
catch (Exception exc)
{
throw new Exception(
"Couldn't transform conditional expression into binary expressions. See inner exception for details.",
exc);
}
return(base.Visit(transformed));
}
protected virtual Expression VisitUnary(UnaryExpression u)
{
var operand = Visit(u.Operand);
return(operand != u.Operand ? Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method) : u);
}
/// <inheritdoc /> protected override Expression VisitUnary(UnaryExpression u) => Expression.MakeUnary(u.NodeType, Visit(u.Operand), u.Type);
/// <summary>
/// Visits the children of the <see cref="UnaryExpression" />.
/// </summary>
/// <param name="node">
/// The expression to visit.
/// </param>
/// <returns>
/// The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.
/// </returns>
protected virtual Expression VisitUnary(UnaryExpression node)
{
var operand = this.Visit(node.Operand);
return(operand != node.Operand ? Expression.MakeUnary(node.NodeType, operand, node.Type, node.Method) : node);
}
protected override Expression VisitUnary(UnaryExpression node) => Linearize(exs => Ex.MakeUnary(node.NodeType, exs[0], node.Type), node.Operand);
private Expression VisitUnary(UnaryExpression u)
{
var operand = Visit(u.Operand !);
return(operand != u.Operand ? Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method) : u);
}
public static Expression UnarySelf(this Expression expression, ExpressionType operation, Type type, MethodInfo method) => Expression.MakeUnary(operation, expression, type, method);
public static Expression UnarySelf(this Expression expression, ExpressionType operation, Type type) => Expression.MakeUnary(operation, expression, type);
internal static SqlExpression Expression(System.Linq.Expressions.Expression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
switch (expression.NodeType)
{
case LqExpressionType.AndAlso:
return(AndAlso(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.Call:
var methodCall = ((MethodCallExpression)expression);
if (methodCall.Method.Name == "Contains" && methodCall.Method.ReturnType == typeof(bool))
{
//System.String的Contants方法。
if (methodCall.Method.ReflectedType == typeof(System.String))
{
return(Like(Expression(methodCall.Object), Expression(methodCall.Arguments[0]), true, true));
}
//System.Linq.Enumerable的Contants方法。注：这是一个扩展方法
if (methodCall.Method.ReflectedType == typeof(System.Linq.Enumerable))
{
if (methodCall.Arguments[1] is MemberExpression && ((MemberExpression)methodCall.Arguments[1]).Expression.NodeType == LqExpressionType.Parameter)
{
return(In(Expression(methodCall.Arguments[1]), (CollectionExpression)Expression(methodCall.Arguments[0])));
}
}
//IList<>/IList的Contants方法
if (methodCall.Method.ReflectedType.GetInterfaces().Any(x => x == typeof(IList) || x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IList <>)))
{
if (methodCall.Arguments[0] is MemberExpression && ((MemberExpression)methodCall.Arguments[0]).Expression.NodeType == LqExpressionType.Parameter)
{
return(In(Expression(methodCall.Arguments[0]), (CollectionExpression)Expression(methodCall.Object)));
}
}
}
else if (methodCall.Method.Name == "StartsWith" && methodCall.Method.ReturnType == typeof(bool))
{
return(Like(Expression(methodCall.Object), Expression(methodCall.Arguments[0]), true, false));
}
else if (methodCall.Method.Name == "EndsWith" && methodCall.Method.ReturnType == typeof(bool))
{
return(Like(Expression(methodCall.Object), Expression(methodCall.Arguments[0]), false, true));
}
else
{
if (methodCall.Method.ReturnType.IsValueType ||
methodCall.Method.ReturnType == typeof(System.String))
{
var obj = LqExpression.Lambda <Func <object> >(LqExpression.MakeUnary(LqExpressionType.Convert, methodCall, typeof(object))).Compile()();
return(Constant(obj));
}
else if (IsEnumerator(methodCall.Method.ReturnType))
{
var obj = LqExpression.Lambda <Func <object> >(LqExpression.MakeUnary(LqExpressionType.Convert, methodCall, typeof(object))).Compile()();
var exps = new CollectionExpression();
foreach (object item in (IEnumerable)obj)
{
exps.Add(Constant(item));
}
return(exps);
}
}
throw new NotSupportedException("不支持的函数调用。");
case LqExpressionType.Equal:
var left = Expression(((Binary)expression).Left);
var right = Expression(((Binary)expression).Right);
if (left is CollectionExpression)
{
return(In(right, (CollectionExpression)left));
}
if (right is CollectionExpression)
{
return(In(left, (CollectionExpression)right));
}
return(Equal(left, right));
case LqExpressionType.GreaterThan:
return(GreaterThan(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.GreaterThanOrEqual:
return(GreaterThanOrEqual(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.LessThan:
return(LessThan(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.LessThanOrEqual:
return(LessThanOrEqual(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.NotEqual:
var left2 = Expression(((Binary)expression).Left);
var right2 = Expression(((Binary)expression).Right);
if (left2 is CollectionExpression)
{
return(NotIn(right2, (CollectionExpression)left2));
}
if (right2 is CollectionExpression)
{
return(NotIn(left2, (CollectionExpression)right2));
}
return(NotEqual(left2, right2));
case LqExpressionType.OrElse:
return(OrElse(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.Add:
return(Add(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.Divide:
return(Divide(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.Modulo:
return(Modulo(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.Multiply:
return(Multiply(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.Subtract:
return(Subtract(Expression(((Binary)expression).Left), Expression(((Binary)expression).Right)));
case LqExpressionType.Constant:
return(Constant(((System.Linq.Expressions.ConstantExpression)expression).Value));
case LqExpressionType.Convert:
return(Expression(((UnaryExpression)expression).Operand));
case LqExpressionType.MemberAccess:
if (((MemberExpression)expression).Expression == null)
{
var obj = LqExpression.Lambda <Func <object> >(LqExpression.MakeUnary(LqExpressionType.Convert, expression, typeof(object))).Compile()();
return(Constant(obj));
}
if (((MemberExpression)expression).Expression.NodeType == LqExpressionType.Parameter)
{
var propertyInfo = (PropertyInfo)PropertyExpression.ExtractMemberExpression(expression).Member;
var fieldInfo = Map.GetCheckedAccessor(propertyInfo.ReflectedType).MetaInfo[propertyInfo];
if (fieldInfo != null)
{
return(Field(fieldInfo.PropertyName));
}
throw new NotSupportedException("实体属性未映射到字段。");
}
var value = LqExpression.Lambda <Func <object> >(LqExpression.MakeUnary(System.Linq.Expressions.ExpressionType.Convert, expression, typeof(object))).Compile()();
if (value is ICollection || (!(value is string) && value is IEnumerable))
{
var exps = new CollectionExpression();
foreach (object item in (IEnumerable)value)
{
exps.Add(Constant(item));
}
return(exps);
}
else
{
return(Constant(value));
}
case LqExpressionType.NewArrayInit:
var array = (Array)LqExpression.Lambda <Func <object> >(LqExpression.MakeUnary(System.Linq.Expressions.ExpressionType.Convert, expression, typeof(object))).Compile()();
var arraycollection = new CollectionExpression(array.Length);
foreach (var item in array)
{
arraycollection.Add(Constant(item));
}
return(arraycollection);
case LqExpressionType.ListInit:
var list = (ICollection)LqExpression.Lambda <Func <object> >(LqExpression.MakeUnary(System.Linq.Expressions.ExpressionType.Convert, expression, typeof(object))).Compile()();
var listcollection = new CollectionExpression(list.Count);
foreach (var item in list)
{
listcollection.Add(Constant(item));
}
return(listcollection);
}
throw new NotSupportedException(string.Format("不受支持的Lambda表达式类型：{0}", expression.NodeType));
}
