Question

我有以下数据结构：

Location { Id, Name }
MeetingRoom { Id, Name, Capacity, CreatedAt }
Meeting {Id, Subject, StartTime, EndTime }
Attendee { Id, Name }

关系是：

位置许多 MeetingRooms
MeetingRoom有一个位置
MeetingRoom有许多会议
会议有一个 MeetingRoom
会议有许多与会者
与会者一次会议

我的查询如下：

 var result = _reader.Query()
                    .Where(location => location.Id == query.Id)
                    .Include(location => location.MeetingRooms)
                        .ThenInclude(room => room.Meetings)
                    .Include(location => location.MeetingRooms)
                        .ThenInclude(room => room.Meetings)
                            .ThenInclude(meeting => meeting.Meeting.Attendees)
                    .Select(location => new LocationWithMeetingRoomsView
                    {
                        Name = location.Name,
                        MeetingRooms = location.MeetingRooms.Select(room => new MeetingRoomWithMeetingsView
                        {
                            Name = room.Name,
                            Capacity = room.Capacity,
                            TotalMeetings = room.Meetings.Count(),
                            AvailableHours = (DateTime.Today.Subtract(room.CreatedAt).TotalDays),
                            MeetingHours = room.Meetings.Sum(meeting => meeting.Meeting.EndTime.Subtract(meeting.Meeting.StartTime).Hours),
                            AverageAttendees = Math.Round(room.Meetings.Average(meeting => meeting.Meeting.Attendees.Count()), 2),
                        }).ToList()
                    })
                    .FirstOrDefault();

以上将产生如下输出：

{
    Name: "Denmark",
    MeetingRooms: [
        { 
            Name: "MeetingRoom 1",
            Capacity: 4,
            TotalMeetings: 947,
            AvailablHours: 245,
            MeetingHours = 2212.2,
            AverageAttendees = 2.84
        },
        ...
    ]
}

请注意TotalMeetings和相应的MeetingHours非常高的问题，因为它始终是该会议室的所有会议实体。我玩弄了这个想法：

TotalMeetings = room.Meetings.Count(meeting => meeting.Meeting.StartTime >= query.From && meeting.Meeting.EndTime <= query.To),

所以＆＃34;将检索到的实体限制在特定的时间段＃34;，但这给了我另一个问题：

AverageAttendees = Math.Round(room.Meetings.Average(meeting => meeting.Meeting.Attendees.Count()), 2)

需要进行相同的过滤，否则参与者的平均数量将适用于所有会议，而不仅仅是过滤后的会议，更不用说我怀疑每次进行内联操作时，我都会创建一个子查询。

因此可以在包含时间上定义where / filter子句，例如：

.Include(room => room.Meetings).Where(meeting => meeting.StartTime >= query.From && meeting.EndTime <= query.To)
.ThenInclude(....

或者我是否必须将查询分开并在多个查询中执行并缓存结果？

Answer 1

不，你可以按照你的建议去做，在include上加上where子句。

EF Core限制加载先前数据聚合/包含时间

1 个答案: