带有GroupBy和Count的EF Core查询无法正常工作

如何解决带有GroupBy和Count的EF Core查询无法正常工作

我有一个带有EF Core 3.1.8的.NET Core 3.1项目。可以说我有两个实体：

public class Card
{
    public int CardId { get; set; }
    public int Stage { get; set; }
    public int SectionId { get; set; }
    public Section Section { get; set; }        
}

public class Section
{
    public int SectionId { get; set; }
    public string Title { get; set; }
    public List<Card> Cards { get; set; }
}

现在，我想要一个查询，该查询为我提供各部分，并为每个部分提供其中有多少张具有Stage = 1，Stage = 2，Stage = 3等的卡的信息。

我尝试过：

var q = _dbContext.Sections
              .Include(s => s.Cards)
              .Select(s => new
              {
                  s.SectionId,cards = s.Cards
                           .Select(c => c.Stage)
                           .GroupBy(c => c)
                           .Select(c => new { c.Key,count = c.Count() })
              })
              .ToList();

但是结果总是只有一张卡片只有一个区域。我该怎么办？

解决方法

我对Group by做了些微调整

 var q = _dbContext.Sections
      .Include(s => s.Cards)
      .GroupBy(s => s.SectionId)
      .Select(s => new
      {
          s.Key,cards = s.SelectMany(t => t.Cards)
                   .GroupBy(c => c.Stage)
                   .Select(c => new { c.Key,count = c.Count() })
      })
      .ToList();

,

当我遇到EntityFramework表现不佳的问题时，我倾向于退一步思考如何直接在SQL中执行此操作。模仿通常会使EF正常工作。

//Create a query to group and count the cards
//In SQL:
//  SELECT SectionId,Stage,COUNT(CardId)
//  FROM Cards
//  GROUP BY SectionId,Stage
//In EF (note,not executing just building up the query):
var cardCountQuery = context.Cards
    .Select(c => new
    {
        c.SectionId,c.Stage
    })
    .GroupBy(c => c)
    .Select(c => new
    {
        SectionAndStage = c.Key,Count = c.Count()
    });

//Now use that as a subquery and join to sections
//In SQL
//  SELECT s.SectionId,s.Title,c.Stage,c.CardCount
//  FROM Sections s
//  INNER JOIN (
//      SELECT  SectionId,COUNT(CardId) AS CardCount
//      FROM    Cards
//      GROUP BY SectionId,Stage
//  ) c ON c.SectionId = s.SectionId
//In EF:
var sectionsWithCardCountByStage = context.Sections
    .Join(cardCountQuery,s => s.SectionId,c => c.SectionAndStage.SectionId,(s,g) => new
    {
        s.SectionId,g.SectionAndStage.Stage,CardCount = g.Count
    })
    .ToList();

编辑：重塑每个评论的数据

接下来，我们可以将数据重塑为您要寻找的内容。

//If you don't mind bring back the Section data multiple times (this will increase the result set size) you can alter the above to bring back the entire Section in the query and then re-shape it in memory.
//NOTE: This will only bring back Sections that have cards
var sectionsWithCardCountByStage = context.Sections
    .Join(cardCountQuery,g) => new
    {
        Section = s,CardCount = g.Count
    })
    .ToList()
    .GroupBy(g => g.Section.SectionId)
    .Select(g => new
    {
        g.First().Section,Cards = g.ToDictionary(c => c.Stage,c => c.CardCount)
    })
    .ToList();

//Or you can bring back Sections only once to reduce result set size.  This extends the query from the first response section above.
var sections = context.Sections
    .Where(s => s.Cards.Count > 0) //Only bring back sections with cards. Remove it to bring back all sections and have an empty dictionary of card counts.
    .ToList()
    .Select(s => new
    {
        Section = s,Cards = sectionsWithCardCountByStage
            .Where(c => c.SectionId == s.SectionId)
            .ToDictionary(c => c.Stage,c => c.CardCount)
    })
    .ToList();

编辑：我尝试最小化查询，只带回完成工作所需的数据。但是，如果您不处理大量数据，那么这可能会提供更紧凑的单个查询选项，但代价是可能会带回更多数据，因此需要更大的结果集。

var sections = context.Sections
    .Include(s => s.Cards)
    .ToList()
    .Select(s => new
    {
        Section = s,CardCount = s.Cards.GroupBy(c => c.Stage)
            .Select(g => new { Stage = g.Key,CardCount = g.Count() })
            .ToDictionary(c => c.Stage,c => c.CardCount)
    })
    .ToList();