我想，可以使用表达式计算的欧几里得距离，并命令一个IQueryable的方法：
SQRT [（Q1 - P1）^ 2 +（Q2 - P2）^ 2 + ... +（QN - PN）^ 2]
这是该方法的签名，我想出了：
public static IOrderedQueryable<T> EuclideanDistanceOrder<T>(
this IQueryable<T> query, IEnumerable<Expression<Func<T, double>>> expressions)
{
var orderedQuery = query.OrderBy(i => Math.Sqrt(expressions.Aggregate((total, item) => total + Math.Pow(item, 2))));
return orderedQuery;
}
我不知道做什么用的item和total （因为它们Expression<Func<T, double>> ）。 我已经试过这几种不同的方法，包括使用Expression.Power和Expression.Add 。 我试着定义单独组成的表达式：
Expression<Func<double, double>> power = i => Math.Pow(i, 2);
Expression<Func<List<Expression<Func<T, double>>>, double>> dist = (items) => Math.Sqrt(items.Sum(power));
但我仍然不知道是做什么用power 。
我能得到一些帮助？ 有没有更好的方式来处理呢？
为了得到它与EF或LinqToSQL工作，你必须通过所有信息，甚至表达的属性访问P和Q：所以这就是为什么我已经修改了你的方法声明：
public static class Extension
{
public static IOrderedQueryable<T> EuclideanDistanceOrder<T>(
this IQueryable<T> query,
IEnumerable<Expression<Func<T, double>>> pExpressions,
IEnumerable<Expression<Func<T, double>>> qExpressions)
{
var parameter = Expression.Parameter(typeof(T));
var pBodies = pExpressions
.Select(x => ReplaceParameter(x.Body, parameter))
.ToArray();
var qBodies = qExpressions
.Select(x => ReplaceParameter(x.Body, parameter))
.ToArray();
var distances = pBodies
.Select((x, i) => CreateDistance(x, qBodies[i]))
.ToArray();
var squers = distances
.Select(x => CreateSquerExpression(x))
.ToArray();
var sum = squers.First();
for (int i = 1; i < squers.Count(); i++)
{
sum = Expression.Add(sum, squers[i]);
}
var funcExpression = Expression.Lambda<Func<T, double>>(sum, parameter);
//the sqrt is irrelevant to order of this sequence
return query.OrderBy(funcExpression);
}
private static Expression CreateDistance(Expression p, Expression q)
{
return Expression.Subtract(q, p);
}
private static Expression CreateSquerExpression(Expression x)
{
var method = typeof(Math).GetMethod("Pow", BindingFlags.Static | BindingFlags.Public);
return Expression.Call(method, x, Expression.Constant(2.0));
}
private static Expression ReplaceParameter(Expression expression, ParameterExpression parameter)
{
var unaryExpression = expression as UnaryExpression;
MemberExpression memberExpression;
if (unaryExpression != null)
{
memberExpression = unaryExpression.Operand as MemberExpression;
}
else
{
memberExpression = expression as MemberExpression;
}
if (memberExpression == null)
throw new NotImplementedException();
if (!(memberExpression.Expression is ParameterExpression) || !(memberExpression.Member is PropertyInfo))
throw new NotImplementedException();
return Expression.Property(parameter, (PropertyInfo)memberExpression.Member);
}
}
虽然调用是这样的：
var list = new[]{ new Item
{
P1 = 0,
Q1 = 0,
P2 = 3,
Q2 = 1,
},
new Item
{
P1 = 0,
Q1 = 0,
P2 = 2,
Q2 = 1,
}
};
var query = list.AsQueryable();
var result = query.EuclideanDistanceOrder(new Expression<Func<Item, double>>[]{
x => x.P1,
x => x.P2
},
new Expression<Func<Item, double>>[]{
x => x.Q1,
x => x.Q2
}).ToArray();
internal class Item
{
public double P1 { get; set; }
public double Q1 { get; set; }
public double P2 { get; set; }
public double Q2 { get; set; }
}
它适用于LIQ对象。 我只是不知道，如果EF或linqtoSql将映射Math.Power方法为SQL。 如果不是很容易不足以改变乘法。
我一直没能对此进行测试，但似乎它应该工作。 有没有平方根底，但顺序应该是相同的两种方式。
public static IOrderedQueryable<T> EuclideanDistanceOrder<T>(this IQueryable<T> query, IEnumerable<Expression<Func<T, double>>> expressions)
{
var parameter = Expression.Parameter(typeof(T), "item");
var seed = Expression.Lambda<Func<T, double>>(Expression.Constant((double)0), parameter);
return query.OrderBy(expressions.Aggregate(seed, GetAggregateExpression));
}
private static Expression<Func<T, double>> GetAggregateExpression<T>(Expression<Func<T, double>> sum, Expression<Func<T, double>> item)
{
var parameter = Expression.Parameter(typeof(T), "item");
return Expression.Lambda<Func<T, double>>(Expression.Add(Expression.Invoke(sum, parameter), Expression.Power(Expression.Invoke(item, parameter), Expression.Constant((double)2))), parameter);
}
编辑：
既然你不能使用Expression.Invoke()你需要内嵌传递到表达式的尸体EuclideanDistanceOrder 。 目前似乎没有任何“好”的方式做到这一点，所以我写了一个Replace的方法来做到这一点。 我只实现Replace了一些比较常见的Expression的类型，希望这将足以覆盖你的使用，但您可能需要实现它的其他Expression类型。
public static IOrderedQueryable<T> EuclideanDistanceOrder<T>(this IQueryable<T> query, IEnumerable<Expression<Func<T, double>>> expressions)
{
var parameter = Expression.Parameter(typeof(T), "item");
var seed = Expression.Constant((double)0);
var agg = expressions.Aggregate((Expression)seed, (s, item) => Expression.Add(s, Expression.Power(Replace(item.Body, item.Parameters[0], parameter), Expression.Constant((double)2))));
return query.OrderBy(Expression.Lambda<Func<T, double>>(agg, parameter));
}
private static Expression Replace(Expression expression, ParameterExpression original, ParameterExpression replacement)
{
if (expression is BinaryExpression)
{
var binaryExpression = (BinaryExpression)expression;
return Expression.MakeBinary(expression.NodeType, Replace(binaryExpression.Left, original, replacement), Replace(binaryExpression.Right, original, replacement), binaryExpression.IsLiftedToNull, binaryExpression.Method, binaryExpression.Conversion);
}
if (expression is ConditionalExpression)
{
var conditionalExpression = (ConditionalExpression)expression;
return Expression.Condition(Replace(conditionalExpression.Test, original, replacement), Replace(conditionalExpression.IfTrue, original, replacement), Replace(conditionalExpression.IfFalse, original, replacement), conditionalExpression.Type);
}
if (expression is ConstantExpression)
{
return expression;
}
if (expression is MemberExpression)
{
var memberExpression = (MemberExpression)expression;
return Expression.MakeMemberAccess(Replace(memberExpression.Expression, original, replacement), memberExpression.Member);
}
if (expression is ParameterExpression)
{
var parameterExpression = (ParameterExpression)expression;
return parameterExpression == original ? replacement : parameterExpression;
}
if (expression is UnaryExpression)
{
var unaryExpression = (UnaryExpression)expression;
return Expression.MakeUnary(unaryExpression.NodeType, Replace(unaryExpression.Operand, original, replacement), unaryExpression.Type, unaryExpression.Method);
}
throw new Exception(string.Format("Unsupported expression type: {0}", expression.NodeType));
}
所以，如果例如，我们输入表达式为：
p => p.X1 - p.X2
p => p.Y1 - p.Y2
原来的实施将已经构造：
i => 0 + expressions[0](i) ^ 2 + expressions[1](i) ^ 2
新的实现将原始表达，并替换输入参数（ p与将被传递到最终拉姆达（参数在上面的） i ），并且使用直接在输出表达式的主体：
i => 0 + (i.X1 - i.X2) ^ 2 + (i.Y1 - i.Y2) ^ 2
