EF核心如何通過另一個列表過濾嵌套的多對多列表

Question

使用.Net Core 2.1和EF Core 2.1.4

我試圖獲取對象的所有嵌套記錄，如果這些記錄中的任何一個包含我在列表中的名稱，並且只有具有匹配嵌套記錄的對象。

我有一個產生正確結果的查詢，但它正在對數據庫表中的每個記錄執行查詢。

如果可能的話，我希望能進一步減少它。

我的ViewModel（實際模型幾乎相同）：

EventViewModel

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;

namespace MyProject.Models.ViewModels
{
    public class EventViewModel
    {
        private string _name;

        public Guid Id { get; set; }

        [Required, StringLength(100)]
        public string Name
        {
            get => _name?.Trim();
            set => _name = value?.Trim();
        }

        [DataType(DataType.Date)]
        public DateTime Date { get; set; }

        [Display(Name = "Programs")]
        public IEnumerable<EventProgramViewModel> EventProgramViewModels { get; set; }

        public string AllProgramNames
        {
            get
            {
                string result = EventProgramViewModels.Aggregate(string.Empty,
                    (current, program) => current + $"{program?.ProgramViewModel?.Name}, ");
                return result.TrimEnd(',', ' ');
            }
        }

        public EventViewModel()
        {
            Id = Guid.NewGuid();
            Date = DateTime.Now;
            EventProgramViewModels = new List<EventProgramViewModel>();
        }
    }
}

EventProgramViewModel

using System;

namespace MyProject.Models.ViewModels
{
    public class EventProgramViewModel
    {
        public Guid EventViewModelId { get; set; }
        public EventViewModel EventViewModel { get; set; }

        public Guid ProgramViewModelId { get; set; }
        public ProgramViewModel ProgramViewModel { get; set; }
    }
}

ProgramViewModel

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace MyProject.Models.ViewModels
{
    public class ProgramViewModel
    {
        private string _name;

        public Guid Id { get; set; }

        [Required, StringLength(100)]
        [Display(Name = "Program Name")]
        public string Name
        {
            get => _name?.Trim();
            set => _name = value?.Trim();
        }
    }
}

在我的ApplicationDbContext.cs文件中，我將其映射為：

modelBuilder.Entity<EventProgram>()
            .HasKey(eventProgram => new {eventProgram.EventId, eventProgram.ProgramId});

最后，這是我的查詢 ：

var testQuery = context.Events
        .AsNoTracking()
        .Select(e => new EventViewModel
        {
            Id = e.Id,
            Name = e.Name,
            Date = e.Date,
            EventProgramViewModels = e.EventPrograms.Select(eventProgram =>
                new EventProgramViewModel
                {
                    ProgramViewModel = new ProgramViewModel
                    {
                        Name = eventProgram.Program.Name
                    }
                })
        })
        .OrderByDescending(eventViewModel => eventViewModel.Date)
        .ThenBy(eventViewModel => eventViewModel.Name)
        .Where(eventViewModel =>
            !search.ProgramsChosen.Any() || eventViewModel.EventProgramViewModels.Any(
                eventProgramViewModel =>
                    search.ProgramsChosen.Contains(eventProgramViewModel.ProgramViewModel
                        .Name)))
        .ToList()
    ;

foreach (var item in testQuery)
{
    // Mock usage to show where queries are generated
    _loggingServices.LogInformation(JsonConvert.SerializeObject(item));
}

這會為主Event屬性生成一個EF查詢：

SELECT [e].[Id], [e].[Name], [e].[Date]
FROM [Events] AS [e]
ORDER BY [e].[Date] DESC, [e].[Name]

每個結果為1（在這種情況下，在上面的foreach循環中）

SELECT [eventProgram.Program].[Name]
FROM [EventPrograms] AS [eventProgram]
INNER JOIN [Programs] AS [eventProgram.Program] ON [eventProgram].[ProgramId] = [eventProgram.Program].[Id]
WHERE @_outer_Id = [eventProgram].[EventId]

有什么辦法可以改善這種表現嗎？

---

更新1：

根據TyCobb的評論，我將查詢結構更改為：

var testQuery =
        context.Events
            .AsNoTracking()
            .OrderByDescending(@event => @event.Date)
            .ThenBy(@event => @event.Name)
            .Where(@event =>
                !search.ProgramsChosen.Any() || @event.EventPrograms.Any(
                    eventProgramViewModel =>
                        search.ProgramsChosen.Contains(eventProgramViewModel.Program
                            .Name)))
            .Select(e => new EventViewModel
            {
                Id = e.Id,
                Name = e.Name,
                Date = e.Date,
                EventProgramViewModels = e.EventPrograms.Select(eventProgram =>
                    new EventProgramViewModel
                    {
                        ProgramViewModel = new ProgramViewModel
                        {
                            Name = eventProgram.Program.Name
                        }
                    })
            })
    ;

哪個更好，因為它只為每個有效記錄生成一個查詢，在此之前它將執行每個記錄。

現在生成這一個查詢：

SELECT [event].[Id], [event].[Name], [event].[Date]
FROM [Events] AS [event]
WHERE EXISTS (
    SELECT 1
    FROM [EventPrograms] AS [eventProgramViewModel]
    INNER JOIN [Programs] AS [eventProgramViewModel.Program] ON [eventProgramViewModel].[ProgramId] = [eventProgramViewModel.Program].[Id]
    WHERE [eventProgramViewModel.Program].[Name] IN (N'A SEARCHED PROGRAM NAME') AND ([event].[Id] = [eventProgramViewModel].[EventId]))
ORDER BY [event].[Date] DESC, [event].[Name]

每個有效記錄一個：

SELECT [eventProgram.Program].[Name]
FROM [EventPrograms] AS [eventProgram]
INNER JOIN [Programs] AS [eventProgram.Program] ON [eventProgram].[ProgramId] = [eventProgram.Program].[Id]
WHERE @_outer_Id = [eventProgram].[EventId]

Answer 1

有兩個問題。

第一個（您使用Update 1解決）是由當前的EF Core查詢轉換缺陷引起的，該缺陷導致客戶端評估Where子句（ OrderBy ）。 因此，在投影之前移動過濾是當前解決方法的方法。

第二個是所謂的N + 1子查詢問題。 EF Core 2.1包含相關子查詢的優化 ，適用於您的情況，但正如文檔中所述，您需要通過添加ToList （或ToArray ）來選擇它：

我們改進了查詢轉換，以避免在許多常見場景中執行“N + 1”SQL查詢，其中投影中導航屬性的使用導致將來自根查詢的數據與來自相關子查詢的數據相關聯。 優化需要緩沖子查詢的結果，並且我們要求您修改查詢以選擇新的行為。

然后

通過在正確的位置包含ToList() ，您可以指示緩沖適用於啟用優化的Orders

所以最終的查詢應該是這樣的：

var testQuery = context.Events
    //.AsNoTracking() <-- No need when using projection
    .OrderByDescending(@event => @event.Date)
    .ThenBy(@event => @event.Name)
    .Where(@event =>
        !search.ProgramsChosen.Any() || @event.EventPrograms.Any(
            eventProgram =>
                search.ProgramsChosen.Contains(eventProgram.Program
                    .Name)))
    .Select(e => new EventViewModel
    {
        Id = e.Id,
        Name = e.Name,
        Date = e.Date,
        EventProgramViewModels = e.EventPrograms.Select(eventProgram =>
            new EventProgramViewModel
            {
                ProgramViewModel = new ProgramViewModel
                {
                    Name = eventProgram.Program.Name
                }
            }).ToList() // <-- 
    })
    .ToList()
    ;

這將導致2個SQL查詢：

SELECT [event].[Id], [event].[Name], [event].[Date]
FROM [Events] AS [event]
WHERE EXISTS (
    SELECT 1
    FROM [EventPrograms] AS [eventProgramViewModel]
    INNER JOIN [Programs] AS [eventProgramViewModel.Program] ON [eventProgramViewModel].[ProgramId] = [eventProgramViewModel.Program].[Id]
    WHERE [eventProgramViewModel.Program].[Name] IN (N'P2', N'P4', N'P7') AND ([event].[Id] = [eventProgramViewModel].[EventId]))
ORDER BY [event].[Date] DESC, [event].[Name], [event].[Id]

和

SELECT [t].[Date], [t].[Name], [t].[Id], [eventProgram.Program].[Name] AS [Name0], [event.EventPrograms].[EventId]
FROM [EventPrograms] AS [event.EventPrograms]
INNER JOIN [Programs] AS [eventProgram.Program] ON [event.EventPrograms].[ProgramId] = [eventProgram.Program].[Id]
INNER JOIN (
    SELECT [event0].[Date], [event0].[Name], [event0].[Id]
    FROM [Events] AS [event0]
    WHERE EXISTS (
        SELECT 1
        FROM [EventPrograms] AS [eventProgramViewModel0]
        INNER JOIN [Programs] AS [eventProgramViewModel.Program0] ON [eventProgramViewModel0].[ProgramId] = [eventProgramViewModel.Program0].[Id]
        WHERE [eventProgramViewModel.Program0].[Name] IN (N'P2', N'P4', N'P7') AND ([event0].[Id] = [eventProgramViewModel0].[EventId]))
) AS [t] ON [event.EventPrograms].[EventId] = [t].[Id]
ORDER BY [t].[Date] DESC, [t].[Name], [t].[Id]