如何使用 Entity Framework Core 从子表列表的每个订单中获取产品行？

Question

I have two model entities:

public class Order
{
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int OrderId { get; set; }
        public Guid OrderGuid { get; set; }
        public string CustomOrderNumber { get; set; }
        public int StoreId { get; set; }
        public int UserId { get; set; }
        public virtual IList<OrderItem> OrderItems { get; set; }
}

public class OrderItem
{
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int OrderItemId { get; set; }
        public Guid OrderItemGuid { get; set; }
        public int OrderId { get; set; }
        public int Sno { get; set; }
        public int ProductId { get; set; }
        public string ProductName { get; set; }
        public int SKUId { get; set; }
        public string SKU { get; set; }
        public int Quantity { get; set; }
        public virtual Order Order { get; set; }
        public virtual ProductSKU ProductSKU { get; set; }
}

I want to get each order with particular product name row from order items.

For example, suppose data in an order,orderitms has 5 product records.

and assume that in that product name is abc having 2 records.

For the 2nd order, order items has 3 records, and one of those as abc product name.

I want get order list with orderitems of abc only... bellow i tried way there. in that I'm getting total orderitems

Please help me?

I tried like this:

List<Contracts.Entities.Order> orders = DbSet.Include(t => t.OrderItems).ToList();

if (!string.IsNullOrEmpty(request.ProductName))
{
    List<OrderItem> orderItems = orders.SelectMany(t => t.OrderItems).Where(t => t.ProductName == request.ProductName).ToList();
    orders = orderItems.Select(t => t.Order).ToList();
}

Answer 1

So every OrderItem has a ProductName, and you want (several properties of) all Orders that have at least on OrderItem with this ProductName.

string productName = ...
var ordersWithProductName = dbContext.Orders.GroupJoin  
    dbContext.OrderItems,             // GroupJoin Orders with OrderItems
    order => order.OrderId            // from every Order take the primary key
    orderItem => orderItem.OrderId,   // from every OrderItem take the foreign key

    // parameter ResultSelector: 
    // take each Order with all its zero or more OrderItems to make one new object
    (order, orderItemsOfThisOrder) => new
    {
        // Select only the Order properties that you plan to use:
        Id = order.OrderId,
        UserId = order.UserId,
        ...

        Items = orderItemsOfThisOrder.Select(orderItem => new
        {
            Id = orderItem.OrderItemId,
            ProductName = orderItem.ProductName,
            ...

            // not needed, you know the value:
            // OrderId = orderItem.OrderId
        })
        .ToList(),
    })

    // keep only those Orders that have at least on OrderItem with productName
    .Where(order => order.Items
                         .Where(orderItem => orderItem.ProductName == productName)
                         .Any());

This way, you get all Orders, each with all its OrderItems, that have at least one OrderItem that has a ProductName equal to productName.

In entity framework you don't have to GroupJoin yourself, you can use the virtual ICollection instead. I'm not sure if ef-core supports this:

    var ordersWithProductName = dbContext.Orders.Select(order => new
    {
        // Select only the Order properties that you plan to use:
        Id = order.OrderId,
        UserId = order.UserId,
        ...

        Items = order.OrderItems.Select(orderItem => new
        {
            Id = orderItem.OrderItemId,
            ProductName = orderItem.ProductName,
            ...

            // not needed, you know the value:
            // OrderId = orderItem.OrderId
        })
        .ToList(),
    })

    // keep only those Orders that have at least on OrderItem with productName
    .Where(order => order.Items
                         .Where(orderItem => orderItem.ProductName == productName)
                         .Any());

One final remark: are you sure that property Order.OrderItems is a List? Does Order.OrderItems[4] have a defined meaning? Shouldn't it be an ICollection<OrderItem> ?

Answer 2

You can write like this:

List<Contracts.Entities.Order> orders = DbSet.Order.Include(t => t.OrderItems).ToList();

        if (!string.IsNullOrEmpty(request.ProductName))
        {
            orders = orders.Where(r => r.OrderItems.Any(rc => rc.ProductName == request.ProductName)).ToList();
        }