什么是选择和组合对象与LINQ的正确方法？

Question

下面是我经常遇到的情况：我有Parent和Child对象，并且Child对象有一个Parent属性。我想运行一个查询，得到的子对象，并加入每一个正确的父对象：

Dim db = New DataContextEx() 

get the children, along with the corresponding parent 
Dim Children = From x In db.ChildTable 
       Join y In db.ParentTable 
       On x.ParentId Equals y.Id 
       Execute x.Parent = y  <-- pseudocode 
       Select x 

的伪代码显示我想要完成的任务：返回子对象X，但与之后的代码（假）执行语句执行。我可以想出很多方法来实现最终目标，但它们都有更多的代码行和/或创建临时对象或函数，我觉得它们不够优雅。 （注意，这是VB.NET语法，但它不是VB语法问题，因为AFAIK C＃会有同样的问题。）

那么最干净的方法来做我想做的事情？人们询问我使用的是什么ORM，但这实际上是一个普通的vanilla LINQ问题;我没有试图将其转换为在服务器上运行的逻辑，我只是​​希望在查询在服务器上运行后，运行代码客户端的一些语法糖。

Answer 1

这些建议，特别是@Paul's，是非常有帮助的，但我的最终版本是不同的，我要写它作为我自己的答案。

我采取了以下完全通用的扩展功能：

<Extension()> _ 
Public Function Apply(Of T)(ByVal Enumerable As IEnumerable(Of T), ByVal action As Action(Of T)) As IEnumerable(Of T) 
    For Each item In Enumerable 
     action(item) 
    Next 

    Return Enumerable 
End Function 

这是一样的ForEach，只不过它返回输入序列，而且我觉得这个名字应用明确指出有副作用效果。然后，我可以写我的查询为：

Dim Children = (
      From x In db.ChildTable 
      Join y In db.ParentTable 
      On x.ParentId Equals y.Id 
      ). 
      Apply(Sub(item) item.x.Parent = item.y). 
      Select(Function(item) item.x) 

当然，这将是更好，如果有一种方法来定制查询操作，所以我就不必使用lambda语法，但即便如此，这似乎很干净且可重复使用。再次感谢所有的帮助。

Answer 2

您可以在投影结果时使用匿名类型。 C＃示例：

var items = from x In db.ChildTable 
      join y In db.ParentTable on x.ParentId equals y.Id 
      select new { Child =x , Parent=y }; 

然后指定父属性。你

foreach(var item in items) 
{ 
    item.Child.Parent = item.Parent; 
} 

return items.Select(item => item.Child); 

可能还需要使用一些ORM解决方案，这不是滚动你自己的。

Answer 3

你可以这样说：

添加的方法做你的逻辑，以返回你选择的查询做逻辑VB this或Me

class Child 
{ 
    public Child GetWithAssignedParent(Parent y) 
    { 
     this.Parent = y; 
     return this; 
    } 
} 

使用这种方法子类并返回子类的实例更新：

var children = from x In db.ChildTable 
join y In db.ParentTable on x.ParentId equals y.Id 
select x.GetWithAssignedParent(y); 

或使用Func键<>

var children = from x in children 
join y in parents on x.ParentId equals y.Id 
select 
    new Func<Child>(() => 
    { 
     x.Parent = y; 
     return x; 
    }).Invoke(); 

Answer 4

这里可能是最简单的解决方案：

var children = from x in db.ChildTable 
       join y in db.ParentTable 
       on x.ParentId equals y.Id 
       // Assign the Parent to the Child: 
       let parent = (x.Parent = y) // <-- Inline assignment (with a dummy variable "parent") 
       select x; 

声明：此查询有直列分配和修改状态 ...这两者都是不被认为是“最佳实践”。
但是，阅读，理解，维护和轻松生成正确的结果非常容易，所以我认为这是一个很好的解决方案。

此外，这只适用于C＃，因为VB.NET没有内嵌分配。

Answer 5

如果您正在使用LinqToObjects，请使用此代码将父项分配给子项。

ILookup<int, Child> lookup = children.ToLookup(c => c.ParentId) 

foreach(Parent p in parents) 
{ 
    foreach(Child c in lookup[p.Id]) 
    { 
    c.Parent = p; 
    } 
} 

---

如果您正在使用LinqToSql，使用DataLoadOptions加载相关的记录。

---

如果您使用的是LinqToEntities，请使用.Include加载相关记录。