哥们，我的对象呢？或者，为什么 Linq 不返回我的对象​​？

Question

获得 Linq 查询的结果后，我并不总是很高兴。可能会出现我期待的结果，但事实并非如此。例如，我的客户期望客户在客户列表中，但事实并非如此。是我的客户在说“伙计，我的客户在哪里？”，而不是我。我是花花公子，要继续做花花公子，我必须给我的客户一个理由。

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

编辑好的，这是一个更好的例子

输出应该是这样的：

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

客户名字是 Carl，但应该是 Daniel

客户年龄为 18 岁，但应大于 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 到只有这些叶子的对象查询。查看对象是否包含在结果中。如果不是，那么我们已经找到了它被排除的原因，如果没有，那么就上树（即，使 where 查询包含更多子句，越来越接近原始子句，直到对象从结果中消失）。

在我看来，最困难的部分是处理原始 linq 到“whatever”和链接到对象之间的差异，找出在哪里拆分 where 子句，处理连接之类的东西，它也可以排除事物和处理事物像 SqlMethods.Like 在 linq to objects 中不起作用。

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!");

这给出了格式良好的结果表：

Answer 3

通过一些有趣的表达式黑客，您可以查看集合中每个项目的每个阶段的评估结果。命中断点后检查本地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 4

这有点棘手，就像在您的示例中一样，您总是可以编写一些代码来检查细节并报告“我搜索了术语 x 并且我返回的对象不在术语 x 中”。

我会像其他人建议的那样，这将与“返回我 x”的行一致，然后在代码中运行“x where x.property = y”的查询并报告不匹配。

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

这与在首先从对象开始并根据条件进行子选择的地方运行查询相反，您想要选择然后选择性地超级选择，捕获非条件。

这是一个有趣的问题，我通常会先解决客户端或代码方面的问题，然后才能确定是否返回对象。但我想完美的解决方案是返回一个单一的解决方案，也许检查它的链接关联。 这些链接不会太难找到一个通用的“我没有这些”类型的原因，但是给出一个“我有这个链接，而不是那个链接”的回应会更难。

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

现在有点漫无边际，但很想听到任何答案！...

Answer 5

我想我明白你的意思。我认为您想要做的是执行两个查询，一个有选择标准，一个没有，然后对它们执行 Linq except 以确定哪些项目被排除在外，然后遍历该列表并确定哪些标准导致它们被排除。

我真的想不出更好的方法。

类似这样的：

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..
}

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

虽然与我想不到的方式相比，但不确定它的效率如何。

编辑：

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

所以在本例中，当foreach() 出现时，将执行单个数据库查询（带有多个子查询）。