C# linq-获取最新的关联记录

假设我有

Customer

和

Order

对象，其中一个

Customer

可以有多个

Order

（因此

Order

类有一个

CustomerId

属性），我想返回所有

CustomerAndMostRecentOrder

对象的集合，这些对象定义如下：

public class CustomerAndMostRecentOrder
{
  public Customer Customer { get; set; }
  public Order MostRecentOrder { get; set; }
}

---

我该如何编写一个Linq查询来实现这一点（我正在使用Linq to SQL）？

您需要在

Order

表中有一个

CreatedDate

日期才能获取最近的订单。然后，要获取

CustomerAndMosterRecentOrder

对象，请执行以下查询：

from c in customers
join o in orders on c.ID equals o.CustomerID into co
select new CustomerAndMostRecentOrder
{
    Customer = c,
    MostRecentOrder = co.OrderByDescending(o => o.CreatedDate).FirstOrDefault()
}

from c in customers
select new CustomerAndMostRecentOrder
    {
        Customer = c,
        MostRecentOrder = c.Orders.OrderByDescending(o => o.PurchaseDate).FirstOrDefault()
    };

---

您需要在

订单

表中有一个

CreatedDate

日期，才能获得最近的订单。然后，要获取

CustomerAndMosterRecentOrder

对象，请执行以下查询：

from c in customers
join o in orders on c.ID equals o.CustomerID into co
select new CustomerAndMostRecentOrder
{
    Customer = c,
    MostRecentOrder = co.OrderByDescending(o => o.CreatedDate).FirstOrDefault()
}

from c in customers
select new CustomerAndMostRecentOrder
    {
        Customer = c,
        MostRecentOrder = c.Orders.OrderByDescending(o => o.PurchaseDate).FirstOrDefault()
    };

---

您可以使用以下查询：

from c in customers
join o in orders on c.ID equals o.CustomerID into co
select new CustomerAndMostRecentOrder
{
    Customer = c,
    MostRecentOrder = co.OrderByDescending(o => o.CreatedDate).FirstOrDefault()
}

from c in customers
select new CustomerAndMostRecentOrder
    {
        Customer = c,
        MostRecentOrder = c.Orders.OrderByDescending(o => o.PurchaseDate).FirstOrDefault()
    };

---

这将使用从客户到订单的导航属性。MostRecentOrder是通过对某些DateTime属性上的订单进行排序，然后加载第一个来获取的。

您可以使用以下查询：

from c in customers
join o in orders on c.ID equals o.CustomerID into co
select new CustomerAndMostRecentOrder
{
    Customer = c,
    MostRecentOrder = co.OrderByDescending(o => o.CreatedDate).FirstOrDefault()
}

from c in customers
select new CustomerAndMostRecentOrder
    {
        Customer = c,
        MostRecentOrder = c.Orders.OrderByDescending(o => o.PurchaseDate).FirstOrDefault()
    };

public class CustomerAndMostRecentOrder
{
    public CustomerAndMostRecentOrder(Customer customer, Order mostRecentOrder)
    {
        Customer = customer;
        MostRecentOrder = mostRecentOrder;
    }

    public Customer Customer { get; set; }
    public Order MostRecentOrder { get; set; }
}

public class Order
{
}


public class Customer
{
    public IEnumerable<Order> GetOrders()
    {

    }
}


public static class UsageClass
{

    public static void Sample(IEnumerable<Customer> allCustomers)
    {
        IEnumerable<CustomerAndMostRecentOrder> customerAndMostRecentOrders =
            allCustomers.Select(customer => new CustomerAndMostRecentOrder(customer, customer.GetOrders().Last()));
    }

}

这将使用从客户到订单的导航属性。通过对某个DateTime属性上的订单进行排序，然后加载第一个订单，可以获得MostRecentOrder。

公共类CustomerAndMosterRecentOrder
public class CustomerAndMostRecentOrder
{
    public CustomerAndMostRecentOrder(Customer customer, Order mostRecentOrder)
    {
        Customer = customer;
        MostRecentOrder = mostRecentOrder;
    }

    public Customer Customer { get; set; }
    public Order MostRecentOrder { get; set; }
}

public class Order
{
}


public class Customer
{
    public IEnumerable<Order> GetOrders()
    {

    }
}


public static class UsageClass
{

    public static void Sample(IEnumerable<Customer> allCustomers)
    {
        IEnumerable<CustomerAndMostRecentOrder> customerAndMostRecentOrders =
            allCustomers.Select(customer => new CustomerAndMostRecentOrder(customer, customer.GetOrders().Last()));
    }

}

{
公共客户和最新订单（客户客户，订单最新订单）
{
客户=客户；
MostRecentOrder=MostRecentOrder；
}
公共客户客户{get；set；}
公共秩序MostRecentOrder{get；set；}
}
公共阶级秩序
{
}
公共类客户
{
公共IEnumerable GetOrders（）
{
}
}
公共静态类UsageClass
{
公共静态无效样本（IEnumerable allCustomers）
{
IEnumerable CustomerAndMosterRecentOrders=
选择（customer=>newcustomerandmostrencentorder（customer，customer.GetOrders（）.Last（））；
}
}

公共类CustomerAndMosterRecentOrder
{
公共客户和最新订单（客户客户，订单最新订单）
{
客户=客户；
MostRecentOrder=MostRecentOrder；
}
公共客户客户{get；set；}
公共秩序MostRecentOrder{get；set；}
}
公共阶级秩序
{
}
公共类客户
{
公共IEnumerable GetOrders（）
{
}
}
公共静态类UsageClass
{
公共静态无效样本（IEnumerable allCustomers）
{
IEnumerable CustomerAndMosterRecentOrders=
选择（customer=>newcustomerandmostrencentorder（customer，customer.GetOrders（）.Last（））；
}
}

作为另一种选择，您可能需要查看在中讨论的DataLoadOptions.AssociateWith。只需在上下文中设置您的要求，您就不必担心在查询级别筛选子项。

作为另一种选择，您可能需要查看DataLoadOptions.AssociateWith（在中讨论）。只需在上下文中设置您的要求，您就不必担心在查询级别筛选子项。

您如何定义“最近”是“最近”呢？这是一个非常好的问题-很抱歉，我忽略了这一点。回答的人只是定义了一个

OrderDate

或

PurchaseDate

属性来订购，这很好-这基本上就是我得到的。你如何定义最近的是最近的？这是一个非常好的问题-很抱歉我忽略了这个。回答问题的人只是定义了一个

OrderDate

或

PurchaseDate

属性来订购，这很好-这基本上就是我得到的。这很好-谢谢。如何在共同集合上应用where子句？可以将扩展方法与lamba一起使用，也可以使用嵌套查询。你想在哪里过滤？例如：获取所有客户和最近一次超过100英镑的订单，或者获取所有客户和最近一次超过100英镑的订单？我真的很抱歉，我无法区分这两种选择。如果

客户

没有超过100英镑的订单，那么我根本不希望

客户

退货。内部连接逻辑。这回答了问题吗？其实这两个例子都不是，它们是3个不同的查询。我刚才想，你需要把

co.Count（o=>o.Amount>100）>0放在
join
之后，但在
select
语句之前。最好使用
Any
方法，而不是说
Count（）>0
。除了
Any
方法看起来更整洁之外，它们做的事情完全相同<代码>其中co.Any（o=>o.Amount>100）

在本例中。这很好-谢谢。如何在共同集合上应用where子句？可以将扩展方法与lamba一起使用，也可以使用嵌套查询。你想在哪里过滤？例如：获取所有客户和最近一次超过100英镑的订单，或者获取所有客户和最近一次超过100英镑的订单？我真的很抱歉，我无法区分这两种选择。如果

客户

没有超过100英镑的订单，那么我根本不希望

客户

退货。内部连接逻辑。这回答了问题吗？其实这两个例子都不是，它们是3个不同的查询。我刚才想，你需要把

co.Count（o=>o.Amount>100）>0放在
join
之后，但在
select
语句之前。最好使用
Any
方法，而不是说
Count（）>0
。除了
Any
方法看起来更整洁之外，它们做的事情完全相同<代码>其中co.Any（o=>o.Amount>100）

在本例中。