| public static Quote ( Expression expression ) : UnaryExpression | ||
| expression | Expression | An |
| return | UnaryExpression | |
private UnaryExpression UnaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var operand = this.Prop(obj, "operand", this.Expression);
var method = this.Prop(obj, "method", this.Method);
switch (nodeType)
{
case ExpressionType.ArrayLength: return(Expr.ArrayLength(operand));
case ExpressionType.Convert: return(Expr.Convert(operand, type, method));
case ExpressionType.ConvertChecked: return(Expr.ConvertChecked(operand, type, method));
case ExpressionType.Decrement: return(Expr.Decrement(operand, method));
case ExpressionType.Increment: return(Expr.Increment(operand, method));
case ExpressionType.IsFalse: return(Expr.IsFalse(operand, method));
case ExpressionType.IsTrue: return(Expr.IsTrue(operand, method));
case ExpressionType.Negate: return(Expr.Negate(operand, method));
case ExpressionType.NegateChecked: return(Expr.NegateChecked(operand, method));
case ExpressionType.Not: return(Expr.Not(operand, method));
case ExpressionType.OnesComplement: return(Expr.OnesComplement(operand, method));
case ExpressionType.PostDecrementAssign: return(Expr.PostDecrementAssign(operand, method));
case ExpressionType.PostIncrementAssign: return(Expr.PostIncrementAssign(operand, method));
case ExpressionType.PreDecrementAssign: return(Expr.PreDecrementAssign(operand, method));
case ExpressionType.PreIncrementAssign: return(Expr.PreIncrementAssign(operand, method));
case ExpressionType.Quote: return(Expr.Quote(operand));
case ExpressionType.Throw: return(Expr.Throw(operand, type));
case ExpressionType.TypeAs: return(Expr.TypeAs(operand, type));
case ExpressionType.UnaryPlus: return(Expr.UnaryPlus(operand, method));
case ExpressionType.Unbox: return(Expr.Unbox(operand, type));
default: throw new NotSupportedException();
}
}
public IQueryable <T> OrderBy(IQueryable <T> query, string expression)
{
var method = typeof(Queryable).GetMember("OrderBy")[0] as MethodInfo;
var methodDesc = typeof(Queryable).GetMember("OrderByDescending")[0] as MethodInfo;
var thenBy = typeof(Queryable).GetMember("ThenBy")[0] as MethodInfo;
var thenByDesc = typeof(Queryable).GetMember("ThenByDescending")[0] as MethodInfo;
Expression current = Parameter;
while (current != null && !(current is ParameterExpression))
{
current = ((MemberExpression)current).Expression;
}
var parts = expression.Split(',');
IQueryable <T> ordered = query;
var index = 0;
QueryParser parser = new QueryParser();
foreach (var part in parts)
{
var value = part.Trim();
string property;
bool descend = false;
if (value.Contains(' '))
{
var split = value.Split(' ');
descend = split[1].Trim().ToLowerInvariant() == "desc";
property = split[0].Trim();
}
else
{
property = value;
}
var astExp = parser.Parse(property);
astExp.CheckSemantic(this);
Expression exp = astExp.GenerateLinqExpression(this);
MethodInfo orderByMethod;
if (index == 0)
{
orderByMethod = descend ? methodDesc : method;
}
else
{
orderByMethod = descend ? thenByDesc : thenBy;
}
index++;
var lambda = Expression.Lambda(exp, (ParameterExpression)current);
ordered = ordered.Provider.CreateQuery <T>(Expression.Call(null, orderByMethod.MakeGenericMethod(new Type[] { typeof(T), exp.Type }), new Expression[] { ordered.Expression, Expression.Quote(lambda) }));
}
return(ordered);
}
