20

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

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

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

输出应该是这样的：

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

客户名字是 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 并比较结果。相反，我正在寻找一种方法来获取单个实例并将其与表达式树进行比较（无需再次直接执行查询）

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

4

5 回答 5

2

我认为您必须将查询重新创建为 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 claues，处理诸如连接之类的东西，它也可以排除一些东西，以及处理类似的东西SqlMethods.Like。不能在 linq to objects 中工作。

于 2012-10-14T19:44:18.317 回答
2

对于过滤掉结果的一次性探索，很难击败LINQPadDump中的方法。这是他们的一个样本的摘录，显示了它的实际效果：

// 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 结果

于 2012-10-14T23:07:29.223 回答
0

通过一些有趣的表达式黑客，您可以看到集合中每个项目的每个阶段的评估结果。命中断点后检查本地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();
        }
    }
}
于 2012-10-15T00:26:21.333 回答
0

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

不过，我会像其他人建议的那样，这将与'return me x'然后在代码中运行一个查询'x where x.property = y'并报告不匹配。

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

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

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

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

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

于 2012-10-14T19:57:28.313 回答
-1

我想我遵循你的意思。我认为您想要做的是执行两个查询，一个有选择标准，一个没有，然后对它们执行 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()发生这种情况时，将执行单个数据库查询（带有多个子查询）。

于 2012-10-14T19:26:41.750 回答