Question

一旦我得到了Linq查询的结果，我并不总是很开心。可能有一个结果，我期待在那里但不是。例如，我的客户希望客户在客户列表中，但事实并非如此。我的客户说“伙计，我的客户在哪里？”，而不是我。我是老兄，为了成为一个老兄，我必须给我的客户原因。

是否有一种简单的方法可以获取给定的对象实例和Linq查询，并确定查询中的哪些表达式排除了该实例？

修改好的，这是一个更好的例子

输出应该是这样的：

您的客户被排除在外有两个原因：

Customer FirstName是Carl，但应该是Daniel

客户年龄为18岁，但应该是＆gt; 20

    public class Customer
    {
        public string FirstName { get; set; }
        public int Age { get; set; }
    }

    [Test]
    public void Dude_wheres_my_object_test1()
    {
        var daniel = new Customer { FirstName = "Daniel", Age = 41 };
        var carl =  new Customer {  FirstName = "Carl", Age= 18 };
        var Customers = new List<Customer>() { daniel, carl };

        // AsQueryable() to convert IEnumerable<T> to IQueryable<T> in 
        //the case of LinqtoObjects - only needed for this test, not 
        //production code where queies written for LinqToSql etc normally 
        //return IQueryable<T>
        var query = from c in Customers.AsQueryable()
                    where c.Age > 20
                    where c.FirstName == "Daniel"
                    select c;
        //query would return Daniel as you'd expect, but not executed here.

        //However I want to explain why Carl was not in the results

        string[] r = DudeWheresMyObject(query, carl);
        Assert.AreEqual("Age is 18 but it should be > 20", r[0]);
        Assert.AreEqual("FirstName is Carl but it should be Daniel", r[1]);


        //Should even work for a Customer who is not 
        //in the original Customers collection...
        var ficticiousCustomer = new Customer { FirstName = "Other", Age = 19};
        string[] r2= DudeWheresMyObject(query, 
                                         ficticiousCustomer);
        Assert.AreEqual("Age is 19 but it should be > 20", r2[0]);
        Assert.AreEqual("FirstName is Other but it should be Daniel", r2[1]);
    }

    public string[] DudeWheresMyObject<T>(IQueryable<T> query, T instance)
    {
        //Do something here with the query.Expression and the instance

    }

首先，在我尝试编写一些花哨的Fluent框架之前，有没有人这样做过？

到目前为止，我已经考虑导航表达式树并针对仅包含我的对象的IQueryable执行每个分支。现在我没有很多使用原始表达树的经验，所以我希望那些不得不提出任何陷阱，甚至解释这是不是死路一条的原因。

我很担心由此造成的任何事情都应该：

可重用 - 应该适用于与返回同一类对象的Linq查询进行比较的任何对象。
不影响原始查询的性能（这应该只是标准的Linq）。
应该是Linq实现不可知的。
如果在缺少的实例上设置了多个属性值，将其从结果中排除，则应报告所有这些原因。

修改我并不是建议我使用不同的查询排列多次对数据库执行LinqToSql并比较结果。相反，我正在寻找一种方法来获取单个实例并将其与表达式树进行比较（不再直接执行查询）

此外，我想了解其他人是否会觉得这有用。如果是这样，我会考虑启动一个开源项目来解决它。

Answer 1

我认为你必须重新创建查询作为linq-to-objects并处理linq-to-sql / entities / whatever和linq-to-objects之间的微妙差异，接受一些提供者刚刚获胜现实地工作。

您想要在内存IEnumerable<T>或其他内容中找到您想要的对象。

你必须以某种方式走过表情树并剪掉树叶，所以说你有：

where obj.foo == true && obj.bar == "yes"

你必须弄清obj.foo == true和obj.bar == "yes"离开并从那里开始。这是对表达式树的一种深度优先搜索。

因此，将linq构造为仅包含那些叶子的对象查询。查看对象是否包含在结果中。如果没有，那么我们已经找到了为什么它被排除在外，如果没有，那么上去树（即使查询包含更多的条款，越接近原始的，直到对象从结果中消失）。

正如我所看到的那样，艰难的部分将处理原始linq与'what'之间的差异以及与对象的链接，找出在哪里分割where claues，处理诸如连接之类的东西，这些东西也可以排除事物和处理事物像SqlMethods.Like那样在linq中不能用于对象。

Answer 2

对于过滤掉结果的一次性探索，很难超越LINQPad中的Dump方法。以下是其中一个样本的摘录，显示了它的实际效果：

// Dump returns exactly what it was given, so you can sneakily inject
// a Dump (or even many Dumps) *within* an expression. This is useful
// for monitoring a query as it progresses:

new[] { 11, 5, 17, 7, 13 }  .Dump ("Prime numbers")
.Where (n => n > 10)        .Dump ("Prime numbers > 10")
.OrderBy (n => n)           .Dump ("Prime numbers > 10 sorted")
.Select (n => n * 10)       .Dump ("Prime numbers > 10 sorted, times 10!");

这提供了格式良好的结果表：

LINQPad results

Answer 3

这是一个棘手的问题，因为在你的例子中，你总是可以编写一些东西来检查细节并报告我搜索了术语x并且我返回的对象不在术语x＆＃39;

然而，正如其他人所建议的那样，我会这样做，这将是为了让我回归x＆＃39;然后在代码中运行查询＆＃39; x其中x.property = y＆＃39;并报告不匹配。

在此之后，我想象的问题是，为了生成不匹配的列表，您的查询或对象图将变得相当大，因为您需要最初包含原始对象（或通过延迟加载扩展以包括）许多排列以确定匹配与否。

这是在第一个地方运行查询的反过来，你首先要根据条件开始对象和子选择，你要选择然后选择性地选择，捕捉非条件。

这是一个有趣的问题，而且我通常会在客户端或代码方面解决这个问题，然后才能到达并返回对象的点。但我想完美的解决方案是返回一个解决方案，或者检查它的链接关联。链接不会太难找到通用＆＃34;我没有得到其中一个＆＃34;键入原因，但要给出一个“我已经有这个链接，而不是那个链接＆＃39;回应会更难。

您可能需要提供一种基于某种形式的谓词构建器的方法，该方法使用字段和搜索项并在事物不匹配时返回相应的消息。在我看来似乎有两个略有不同的问题。

现在略微散步，但很想听到任何答案！...

Answer 4

通过一些有趣的表达式黑客攻击，您可以看到集合中每个项目的评估的每个阶段的结果。在点击断点后检查本地result以查看评估结果。要实际使用评估结果，只需将.Where(x => x.IsIncludedInResult).Select(x => x.EvaluationTarget)附加到生成报告的行。

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;

namespace ConsoleApplication4
{
    [DebuggerDisplay("{Condition} on {EvaluationTarget} is {EvaluationResult}")]
    public class ReportItem<T>
    {
        public string Condition { get; private set; }

        public IEnumerable<ReportItem<T>> NestedReports { get; private set; }

        public object EvaluationResult { get; private set; }

        public T EvaluationTarget { get; private set; }

        public ReportItem(Expression condition, IEnumerable<ReportItem<T>> nestedReports, T evaluationTarget, object evaluationResult)
        {
            Condition = condition.ToString();
            NestedReports = nestedReports;
            EvaluationTarget = evaluationTarget;
            EvaluationResult = evaluationResult;
        }

        public override string ToString()
        {
            return string.Format("{0} on {1} is {2}", Condition, EvaluationTarget, EvaluationResult);
        }
    }

    [DebuggerDisplay("Included: {IsIncludedInResult} \n{Summary}")]
    public class Report<T>
    {
        public ReportItem<T> Contents { get; private set; }

        public T EvaluationTarget { get; private set; }

        public Report(T source, Expression<Func<T, bool>> predicate)
        {
            EvaluationTarget = source;

            IsIncludedInResult = predicate.Compile()(source);

            Contents = Recurse(predicate.Parameters.Single(), predicate.Body, source);
        }

        private object Evaluate(Expression expression, ParameterExpression parameter, T source)
        {
            var expr = Expression.Lambda(expression, parameter);
            var @delegate = expr.Compile();
            var value = @delegate.DynamicInvoke(source);
            return value;
        }

        private ReportItem<T> Recurse(ParameterExpression parameter, Expression sourceExpression, T source)
        {
            var constantExpression = sourceExpression as ConstantExpression;

            if(constantExpression != null)
            {
                return new ReportItem<T>(sourceExpression, null, source, Evaluate(constantExpression, parameter, source));
            }

            var unaryExpression = sourceExpression as UnaryExpression;

            if(unaryExpression != null)
            {
                var content = Recurse(parameter, unaryExpression.Operand, source);
                var result = Evaluate(sourceExpression, parameter, source);
                return new ReportItem<T>(sourceExpression, new[]{content}, source, result);
            }

            var binaryExpression = sourceExpression as BinaryExpression;

            if(binaryExpression != null)
            {
                var left = Recurse(parameter, binaryExpression.Left, source);
                var right = Recurse(parameter, binaryExpression.Right, source);
                var item = new ReportItem<T>(sourceExpression, new[] {left, right}, source, Evaluate(sourceExpression, parameter, source));
                return item;
            }

            var methodCallExpression = sourceExpression as MethodCallExpression;

            if(methodCallExpression != null)
            {
                var args = methodCallExpression.Arguments.Select(x => Evaluate(x, parameter, source)).ToArray();
                var result = methodCallExpression.Method.Invoke(Expression.Lambda(methodCallExpression.Object, parameter).Compile().DynamicInvoke(source), args);
                return new ReportItem<T>(sourceExpression, null, source, result);
            }

            throw new Exception("Unhandled expression type " + sourceExpression.NodeType + " encountered");
        }

        public bool IsIncludedInResult { get; private set; }

        public string Summary
        {
            get { return Contents.ToString(); }
        }

        public override string ToString()
        {
            return Summary;
        }
    }

    public static class PredicateRunner
    {
        public static IEnumerable<Report<T>> Report<T>(this IEnumerable<T> set, Expression<Func<T, bool>> predicate)
        {
            return set.Select(x => new Report<T>(x, predicate));
        }
    }

    class MyItem
    {
        public string Name { get; set; }

        public int Value { get; set; }

        public override int GetHashCode()
        {
            return Value % 2;
        }

        public override string ToString()
        {
            return string.Format("Name: \"{0}\" Value: {1}", Name, Value);
        }
    }

    class Program
    {
        static void Main()
        {
            var items = new MyItem[3];
            items[0] = new MyItem
            {
                Name = "Hello",
                Value = 1
            };

            items[1] = new MyItem
            {
                Name = "Hello There",
                Value = 2
            };
            items[2] = new MyItem
            {
                Name = "There",
                Value = 3
            };

            var result = items.Report(x => !x.Name.Contains("Hello") && x.GetHashCode() == 1).ToList();
            Debugger.Break();
        }
    }
}

Answer 5

我想我遵循你的意思。我认为你想要做的是执行两个查询，一个有选择标准，一个没有，然后执行Linq除了它们以确定哪些项被排除，然后走这个列表并确定导致它们被排除的标准。

我无法想到更好的方法。

这样的事情：

var a = db.Trades.Where(z => z.user == x && z.date == y);

var b = a.Where(z => z.TradeCurrency != null && z.TradeUnderlying.Index != null);

var c = a.Except(b);

List<string> reasons;
foreach(var d in c) {
    if (d.TradeCurrency == null)
        // add reason
    ... etc..
}

这将执行单个查询（可能有多个子查询）并且只返回被排除的结果（而不是尝试返回可能非常大的所有结果）。除非你当然有100万个被排除的记录，只有少数被记录的记录。

虽然与我无法想到的方式相比，但不确定这是多么有效。

修改

我认为您忘记了Linq查询在您调用实现它们的操作之前不会执行。在这个例子中，数据库只被命中一次，即使这里有几个linq查询对象。修改表达式树而不执行查询。

因此，在此示例中，当foreach()发生时，将执行单个数据库查询（包含多个子查询）。

老兄，我的对象在哪里？或者，为什么Linq没有归还我的对象？

5 个答案: