linq中的条件包含到实体？

我觉得下面应该是可能的，我只是不确定该采取什么方法

我想做的是使用include方法来塑造我的结果，即定义沿对象图要遍历的距离。但是我希望遍历是有条件的

something like...

dealerships
    .include( d => d.parts.where(p => p.price < 100.00))
    .include( d => d.parts.suppliers.where(s => s.country == "brazil"));

类似于。。。
经销商
.包括（d=>d.零件，其中（p=>p.价格<100.00））
.包括（d=>d.parts.suppliers.where（s=>s.country==“巴西”）；

我知道这是无效的linq，事实上，这是非常错误的，但本质上我正在寻找某种方法来构建一个表达式树，它将返回成形的结果，相当于

select *
from dealerships as d
outer join parts as p on d.dealerid = p.dealerid
    and p.price < 100.00
outer join suppliers as s on p.partid = s.partid
    and s.country = 'brazil'

选择*
从经销商处获得d
外部连接零件，如d上的p.dealerid=p.dealerid
p.价格<100.00
在p.partid=s.partid上以s的形式连接外部供应商
而美国国家=‘巴西’

重点介绍了连接条件

我觉得这对于esql来说是相当直接的，但我更喜欢动态地构建表达式树

---

一如既往，感谢您的建议或指导

我是否遗漏了什么，或者您是否只是在寻找

any

关键字

var query = dealerships.Where(d => d.parts.Any(p => p.price < 100.00) || 
                              d.parts.suppliers.Any(s => s.country == "brazil"));

var query=经销商。其中（d=>d.parts.Any（p=>p.price<100.00）|
d、 零件。供应商。任何（s=>s.country==“巴西”）；

你确定这就是你想要的吗？我问的唯一原因是，一旦你在经销商的零件上添加了过滤器，你的结果就不再是经销商了。您所处理的特殊对象在很大程度上非常接近经销商（具有相同的属性），但“Parts”属性的含义不同。它不是经销商和零件之间的关系，而是经过过滤的关系

或者换句话说，如果我从您的结果中提取经销商并将其传递给我编写的方法，然后在我的方法中调用：

var count = dealership.Parts.Count();

我希望得到的零件，而不是从巴西过滤的零件，那里的价格低于100美元

如果您不使用经销商对象传递过滤后的数据，那么这将变得非常容易。它变得非常简单：

    var query = from d in dealerships
               select new { DealershipName = d.Name, 
CheapBrazilProducts = dealership.Parts.Where(d => d.parts.Any(p => p.price < 100.00) || d.parts.suppliers.Any(s => s.country == "brazil")) };

var query=来自经销商中的d
选择new{DealershipName=d.Name，
CheapBrazilProducts=经销商.Parts.Where（d=>d.Parts.Any（p=>p.price<100.00）| | d.Parts.suppliers.Any（s=>s.country==“巴西”））；

如果我必须按照你的要求获得过滤集，我可能会使用上面提到的技术，然后使用Automapper之类的工具将过滤结果从匿名类复制到真实类。这不是难以置信的优雅，但它应该可以工作

---

我希望这有帮助！这是一个有趣的问题。

这应该可以做到：

using (TestEntities db = new TestEntities())
{
    var query = from d in db.Dealership
                select new
                {
                    Dealer = d,
                    Parts = d.Part.Where
                    (
                        p => p.Price < 100.0 
                             && p.Supplier.Country == "Brazil"
                    ),
                    Suppliers = d.Part.Select(p => p.Supplier)
                };

    var dealers = query.ToArray().Select(o => o.Dealer);
    foreach (var dealer in dealers)
    {
        Console.WriteLine(dealer.Name);
        foreach (var part in dealer.Part)
        {
            Console.WriteLine("  " + part.PartId + ", " + part.Price);
            Console.WriteLine
                (
                "  " 
                + part.Supplier.Name 
                + ", " 
                + part.Supplier.Country
                );
        }
    }
}

---

但我同意Darren的观点，这可能不是您图书馆的用户所期望的。

是的，这就是我想要做的。我认为下一个真正的数据服务将有可能只做LINQ到REST查询，这将非常好，同时我刚刚切换到加载反向，并包括将要加载的相关实体可以多次加载，但理论上，它只需在第一个Include中加载一次，就像在这个代码中一样

return this.Context.SearchHistories.Include("Handle")
    .Where(sh => sh.SearchTerm.Contains(searchTerm) && sh.Timestamp > minDate && sh.Timestamp < maxDate);

返回this.Context.SearchHistories.Include（“句柄”）
其中（sh=>sh.SearchTerm.Contains（SearchTerm）&&sh.Timestamp>minDate&&sh.Timestamp

---

在我尝试为任何句柄加载与逻辑匹配的SearchHistory之前，我不知道如何使用您发布的Include逻辑，因此同时我认为反向查找将是一个不太脏的解决方案

我知道这可以在一个Include中工作。从不使用两个包含项进行测试，但值得一试：

dealerships
    .Include( d => d.parts)
    .Include( d => d.parts.suppliers)
    .Where(d => d.parts.All(p => p.price < 100.00) && d.parts.suppliers.All(s => s.country == "brazil"))

经销商
.包括（d=>d.零件）
.包括（d=>d.零件.供应商）
其中（d=>d.parts.All（p=>p.price<100.00）和&d.parts.suppliers.All（s=>s.country==“巴西”））

我不这么认为，据我所知，这将退回符合条件的零件和供应商的经销商，而不是退回所有经销商、100岁以下的零件和巴西的所有供应商。我意识到这应该是一个外部连接。我想我要做的是修剪结果树，而不是根据树下的值筛选顶级节点。你有没有找到解决方案？我也有同样的问题。还没有，但我仍然感兴趣，并将继续追求……我一直在寻找相同的东西，Darren，就物体身份而言，我同意！我还担心，这正是EF可能不支持的原因。我在这里真正想做的是将一个查询字符串解析成一个查询表达式，比如<100）/suppliers（s.country==brazil），并在EF处检查它，使用一个定制的xml序列化策略，然后使用RestQL引擎（restful查询语言）。我不太喜欢EF，但我希望能够有模型抽象和表达式树，EF是，不想偏离MS堆栈太远！抱歉，darren，请在进一步的答案中查看此文本，以便更具可读性！关于这一点，我尝试了这个，但一开始它不起作用。我最终发现，我打开了惰性加载，这导致它无法工作。一旦我关闭了懒加载，这就像一个魅力。谢谢你，雅各布！这要求您返回一个匿名类型，而不是带有实际引用的原始类型。这“确实有效”，但让我需要一个解决方案来返回原始对象，并将实际收集对象过滤为我实际想要返回的对象。匿名返回类型确实有效。。。但这并不是真正需要的解决方案。@您可以通过以下方式返回类型化列表：

var-deralers=query.ToArray（）.Select（o=>o.deraler.ToList（）它只是工作！我更喜欢这种方式，所以我不会创建不必要的数组：
query.Load（）；var-deralers=query.Select（o=>o.deraler.ToList（）
dealerships
    .Include( d => d.parts)
    .Include( d => d.parts.suppliers)
    .Where(d => d.parts.All(p => p.price < 100.00) && d.parts.suppliers.All(s => s.country == "brazil"))