查询c#列表以限制子项但返回父项

我有一个嵌套的列表结构，其中包含客户->订单->订单项。我试图找到一个LINQ或其他查询，它将返回OrderItem quantity=1的客户及其嵌套项目。但是，如果数量！=一,

我试过这个：

var customers2 = customers.Where(c => c.Orders.Any(o => o.OrderItems.Exists(oi => oi.Quantity == 1)));

它只正确返回订单项数量为1的客户，但也返回所有其他订单和订单项

我可以通过两个For-each循环获得所需的结果，但我想找到更优雅的：

        foreach (var customer in customers2)
        {
            customer.Orders = customer.Orders.Where(o => o.OrderItems.Exists(oi => oi.Quantity == 1)).ToList();

            foreach (var order in customer.Orders)
            {
                order.OrderItems = order.OrderItems.Where(oi => oi.Quantity == 1).ToList();
            }
        }

下面是对象结构和一些示例数据

public class Customer
{
    public int CustomerId { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
    public List<Order> Orders { get; set; }
}

public class Order
{
    public int OrderId { get; set; }
    public int CustomerId { get; set; }
    public DateTime OrderDate { get; set; }
    public bool Shipped { get; set; }
    public List<OrderItem> OrderItems { get; set; }
}

public class OrderItem
{
    public int OrderItemId { get; set; }
    public int OrderId { get; set; }
    public string ItemName { get; set; }
    public int Quantity { get; set; }
}

        var customers = new List<Customer>
        {
            new Customer
            {
                CustomerId = 1,
                Name = "Shawn",
                Address = "123 Main Street",
                Orders = new List<Order>()
                {
                    new Order()
                    {
                        OrderId = 100,
                        CustomerId = 1,
                        OrderDate = DateTime.Now,
                        Shipped = true,
                        OrderItems = new List<OrderItem>()
                        {
                            new OrderItem()
                            {
                                OrderItemId = 200,
                                OrderId = 100,
                                ItemName = "Computer",
                                Quantity = 1
                            },
                            new OrderItem()
                            {
                                OrderItemId = 206,
                                OrderId = 100,
                                ItemName = "Hard Drive",
                                Quantity = 2
                            }
                        }
                    },
                    new Order()
                    {
                        OrderId = 106,
                        CustomerId = 1,
                        OrderDate = DateTime.Now,
                        Shipped = true,
                        OrderItems = new List<OrderItem>()
                        {
                            new OrderItem()
                            {
                                OrderItemId = 207,
                                OrderId = 106,
                                ItemName = "Monitor",
                                Quantity = 3
                            },
                            new OrderItem()
                            {
                                OrderItemId = 208,
                                OrderId = 106,
                                ItemName = "DVD Burner",
                                Quantity = 2
                            }
                        }
                    }
                }
            },
            new Customer
            {
                CustomerId = 2,
                Name = "Arianna",
                Address = "456 Main Street",
                Orders = new List<Order>()
                {
                    new Order()
                    {
                        OrderId = 101,
                        CustomerId = 2,
                        OrderDate = DateTime.Now.AddDays(-10),
                        Shipped = true,
                        OrderItems = new List<OrderItem>()
                        {
                            new OrderItem()
                            {
                                OrderItemId = 201,
                                OrderId = 101,
                                ItemName = "barbie",
                                Quantity = 2
                            }
                        }
                    }
                }
            },
            new Customer
            {
                CustomerId = 3,
                Name = "Ryan",
                Address = "789 Main Street",
                Orders = new List<Order>()
                {
                    new Order()
                    {
                        OrderId = 102,
                        CustomerId = 3,
                        OrderDate = DateTime.Now.AddDays(-5),
                        Shipped = true,
                        OrderItems = new List<OrderItem>()
                        {
                            new OrderItem()
                            {
                                OrderItemId = 203,
                                OrderId = 103,
                                ItemName = "Minecraft",
                                Quantity = 2
                            }
                        }
                    }
                }
            }
        };

公共类客户
{
public int CustomerId{get；set；}
公共字符串名称{get；set；}
公共字符串地址{get；set；}
公共列表顺序{get；set；}
}
公共阶级秩序
{
公共int-OrderId{get；set；}
public int CustomerId{get；set；}
public DateTime OrderDate{get；set；}
公共bool{get；set；}
公共列表OrderItems{get；set；}
}
公共类OrderItem
{
公共整型OrderItemId{get；set；}
公共int-OrderId{get；set；}
公共字符串ItemName{get；set；}
公共整数数量{get；set；}
}
var客户=新列表
{
新客户
{
CustomerId=1，
Name=“Shawn”，
地址=“主街123号”，
订单=新列表（）
{
新秩序（）
{
OrderId=100，
CustomerId=1，
OrderDate=DateTime。现在，
Shipped=true，
OrderItems=新列表（）
{
新订单项（）
{
OrderItemId=200，
OrderId=100，
ItemName=“计算机”，
数量=1
},
新订单项（）
{
OrderItemId=206，
OrderId=100，
ItemName=“硬盘驱动器”，
数量=2
}
}
},
新秩序（）
{
OrderId=106，
CustomerId=1，
OrderDate=DateTime。现在，
Shipped=true，
OrderItems=新列表（）
{
新订单项（）
{
OrderItemId=207，
OrderId=106，
ItemName=“监视器”，
数量=3
},
新订单项（）
{
OrderItemId=208，
OrderId=106，
ItemName=“DVD刻录机”，
数量=2
}
}
}
}
},
新客户
{
CustomerId=2，
Name=“阿里安娜”，
Address=“456大街”，
订单=新列表（）
{
新秩序（）
{
OrderId=101，
CustomerId=2，
OrderDate=DateTime.Now.AddDays（-10），
Shipped=true，
OrderItems=新列表（）
{
新订单项（）
{
OrderItemId=201，
OrderId=101，
ItemName=“芭比”，
数量=2
}
}
}
}
},
新客户
{
CustomerId=3，
Name=“Ryan”，
Address=“789大街”，
订单=新列表（）
{
新秩序（）
{
OrderId=102，
CustomerId=3，
OrderDate=DateTime.Now.AddDays（-5），
Shipped=true，
OrderItems=新列表（）
{
新订单项（）
{
OrderItemId=203，
OrderId=103，
ItemName=“Minecraft”，
数量=2
}
}
}
}
}
};

我想有一个较短的解决方案，但这是可行的：

var goodCusts = new List<Customer>();

foreach(var customer in customers)
{
    var testCust = customer;

    for (int i = testCust.Orders.Count - 1; i >= 0; i--) 
    {
        if (testCust.Orders[i].OrderItems.Count != 1)
            testCust.Orders.RemoveAt(i);
    }

    if (testCust.Orders.Any())
        goodCusts.Add(testCust);        
}

var goodCusts=new List（）；
foreach（客户中的var客户）
{
var testCust=客户；
对于（int i=testCust.Orders.Count-1；i>=0；i--）
{
if（testCust.Orders[i].OrderItems.Count！=1）
测试客户订单移除（i）；
}
if（testCust.Orders.Any（））
goodCusts.Add（testCust）；
}

---

不过，它确实创建了一个新集合。它只是通过每个客户运行，删除所有带有

OrderItems.Count！=1

，然后测试该客户是否有剩余的

订单。如果有，它将被添加到
列表
结果中。
您使用的路径是正确的

var customers2 = customers
    .Where(c => c.Orders.Any(o => o.OrderItems.Exists(oi => oi.Quantity == 1)));

你只是
var customers2 = customers
    .Where(c => c.Orders.Any(o => o.OrderItems.Exists(oi => oi.Quantity == 1)))
    .Select(c => c.Orders.Where(o => o.OrderItems(o => o.OrderItems.Exists(oi => oi.Quantity == 1)));

var customers2 = customers
    .Where(c => c.Orders.Any(o => o.OrderItems.Exists(oi => oi.Quantity == 1)))
    .Select(c => new
       {
       Customer = c,
       FilteredOrders =  c.Orders.Where(o => o.OrderItems(o => o.OrderItems.Exists(oi => oi.Quantity == 1))
       });

foreach(var cust in customers2)
{
   cust.Customer // your original Customer object
   cust.Customer.Orders // your original orders collection for this Customer
   cust.FilteredOrders // only the orders you're interested in for this customer
}

var customers2 = customers.Where(x => x.Orders != null && x.Orders.Any(y => y.OrderItems != null && y.OrderItems.Any(z => z.Quantity == 1)));

customers2.ToList().ForEach(x => 
{
    x.Orders.ForEach(y => 
    {
        y.OrderItems.RemoveAll(z => z == null || z.Quantity != 1);
    });

    x.Orders.RemoveAll(y => y == null || y.OrderItems.Count == 0);
});

return customers2;

    public static List<Customer> GetCustomersWithOrderItemQuantity(List<Customer> customers, int quantity)
    {

        var customers2 = customers.TakeWhile(c => c.Orders.Any(o => o.OrderItems.Any(oi => oi.Quantity == quantity))).ToList();
        customers2.ForEach(cust => cust.Orders.ForEach(o => o.OrderItems.RemoveAll(oi => oi.Quantity != quantity)));
        return customers2;
    }

var customers2 = GetCustomersWithOrderItemQuantity(customers, 1);

    public static IEnumerable<Customer> GetCustomersWithOrderItemQuantity(List<Customer> customers, int quantity)
    {
        return customers.TakeWhile(c => c.Orders.Any(o => o.OrderItems.Any(oi => oi.Quantity == quantity)));
    }