如何从导航属性中查询 EF Core dbcontext 的特定属性？

Question

I'm trying to get the most efficient query for selecting some nested attributes in navigation properties so the API sends a response which contains only relevant information. So far I tried the Include() and ThenInclude() approach and the answer on this post .

However both approaches produced similar queries and retrieved the same columns from the database. The only noticeable difference being that the Include approach loaded the data from unneeded columns into the entity object attributes while the Select() approach didn't. I'm using a layer pattern so using null type isn't much of an option for me and the nul values in the entity aren't a problem as only the retrieves values are eventually loaded into the dto, but still the query efficiency question remains.

My question is if there is a better way to query single columns from navigation properties and if not which of the two mentioned ways is better.

Include query method:

public async Task<IEnumerable<Orden>> GetDetailed()
{
    return await _context.Ordenes
                         .Include(o => o.Detalles)
                         .ThenInclude(od => od.ProductosAlmacenados)
                         .Include(o => o.Detalles)
                         .ThenInclude(od => od.Tela)
                         .Include(o => o.Detalles)
                         .ThenInclude(od => od.Color)
                         .ToListAsync();
}

Select() query method:

public async Task<IEnumerable<Orden>> GetDetailed()
{
    var ordenes = await _context.Ordenes
                                .Select(o => new Orden
        {
            Id = o.Id,
            Estatus = o.Estatus,
            FechaRegistro = o.FechaRegistro,
            FechaRequerida = o.FechaRequerida,
            Detalles = o.Detalles.Select(d => new OrdenDetalles
            {
                Color = new Color
                {
                    Nombre = d.Color.Nombre
                },
                Tela = new Tela
                {
                    Nombre = d.Tela.Nombre,
                },
                Cantidad = d.Cantidad,
                ProductosAlmacenados = d.ProductosAlmacenados
            }).ToList()
        }
        ).ToListAsync();

    return ordenes;
}

Query generated by Select with output:

SELECT `o`.`ID`, `o`.`Estatus`, `o`.`Fecha_Registro`, `o`.`Fecha_Requerida`, `t0`.`Nombre`, `t0`.`Nombre0`, `t0`.`Cantidad`, `t0`.`Color_ID`, `t0`.`Orden_ID`, `t0`.`Tela_ID`, `t0`.`ID`, `t0`.`ID0`, `t0`.`Almacen_ID`, `t0`.`OrdenDetalles_Color_ID`, `t0`.`OrdenDetalles_Orden_ID`, `t0`.`OrdenDetalles_Tela_ID`, `t0`.`Cantidad0`
  FROM `orden` AS `o`
  LEFT JOIN (
      SELECT `c`.`Nombre`, `t`.`Nombre` AS `Nombre0`, `o0`.`Cantidad`, `o0`.`Color_ID`, `o0`.`Orden_ID`, `o0`.`Tela_ID`, `c`.`ID`, `t`.`ID` AS `ID0`, `a`.`Almacen_ID`, `a`.`OrdenDetalles_Color_ID`, `a`.`OrdenDetalles_Orden_ID`, `a`.`OrdenDetalles_Tela_ID`, `a`.`Cantidad` AS `Cantidad0`
      FROM `ordendetalles` AS `o0`
      INNER JOIN `color` AS `c` ON `o0`.`Color_ID` = `c`.`ID`
      INNER JOIN `tela` AS `t` ON `o0`.`Tela_ID` = `t`.`ID`
      LEFT JOIN `almacen_productos` AS `a` ON ((`o0`.`Color_ID` = `a`.`OrdenDetalles_Color_ID`) AND (`o0`.`Orden_ID` = `a`.`OrdenDetalles_Orden_ID`)) AND (`o0`.`Tela_ID` = `a`.`OrdenDetalles_Tela_ID`)
  ) AS `t0` ON `o`.`ID` = `t0`.`Orden_ID`
  ORDER BY `o`.`ID`, `t0`.`Color_ID`, `t0`.`Orden_ID`, `t0`.`Tela_ID`, `t0`.`ID`, `t0`.`ID0`, `t0`.`Almacen_ID`, `t0`.`OrdenDetalles_Color_ID`, `t0`.`OrdenDetalles_Orden_ID`

MySQlWorkbench output

Query generated by Include() :

SELECT `o`.`ID`, `o`.`Estatus`, `o`.`Fecha_Registro`, `o`.`Fecha_Requerida`, `t0`.`Color_ID`, `t0`.`Orden_ID`, `t0`.`Tela_ID`, `t0`.`Cantidad`, `t0`.`ID`, `t0`.`ID0`, `t0`.`Almacen_ID`, `t0`.`OrdenDetalles_Color_ID`, `t0`.`OrdenDetalles_Orden_ID`, `t0`.`OrdenDetalles_Tela_ID`, `t0`.`Cantidad0`, `t0`.`Nombre`, `t0`.`Nombre0`
  FROM `orden` AS `o`
  LEFT JOIN (
      SELECT `o0`.`Color_ID`, `o0`.`Orden_ID`, `o0`.`Tela_ID`, `o0`.`Cantidad`, `t`.`ID`, `c`.`ID` AS `ID0`, `a`.`Almacen_ID`, `a`.`OrdenDetalles_Color_ID`, `a`.`OrdenDetalles_Orden_ID`, `a`.`OrdenDetalles_Tela_ID`, `a`.`Cantidad` AS `Cantidad0`, `t`.`Nombre`, `c`.`Nombre` AS `Nombre0`
      FROM `ordendetalles` AS `o0`
      INNER JOIN `tela` AS `t` ON `o0`.`Tela_ID` = `t`.`ID`
      INNER JOIN `color` AS `c` ON `o0`.`Color_ID` = `c`.`ID`
      LEFT JOIN `almacen_productos` AS `a` ON ((`o0`.`Color_ID` = `a`.`OrdenDetalles_Color_ID`) AND (`o0`.`Orden_ID` = `a`.`OrdenDetalles_Orden_ID`)) AND (`o0`.`Tela_ID` = `a`.`OrdenDetalles_Tela_ID`)
  ) AS `t0` ON `o`.`ID` = `t0`.`Orden_ID`
  ORDER BY `o`.`ID`, `t0`.`Color_ID`, `t0`.`Orden_ID`, `t0`.`Tela_ID`, `t0`.`ID`, `t0`.`ID0`, `t0`.`Almacen_ID`, `t0`.`OrdenDetalles_Color_ID`, `t0`.`OrdenDetalles_Orden_ID`

Output

Orden entity:

public partial class Orden
{
    public Orden()
    {
        Detalles = new HashSet<OrdenDetalles>();
    }

    public int Id { get; set; }
    public DateTime FechaRegistro { get; set; }
    public DateTime FechaRequerida { get; set; }
    public Estado Estatus { get; set; }

    public virtual ICollection<OrdenDetalles> Detalles { get; set; }
}

OrdenDetalles entity:

public partial class OrdenDetalles
{
    public OrdenDetalles()
    {
        ProductosAlmacenados = new HashSet<ProductoAlmacenado>();
    }

    public int ColorId { get; set; }
    public int OrdenId { get; set; }
    public int TelaId { get; set; }
    public int Cantidad { get; set; }

    public virtual Color Color { get; set; }
    public virtual Orden Orden { get; set; }
    public virtual Tela Tela { get; set; }
    public virtual ICollection<ProductoAlmacenado> ProductosAlmacenados { get; set; }
}

If any other information is needed please let me know in the comments

Answer 1

Projection using Select is generally the better approach however, do not use Select to populate Entity classes, rather populate DTOs or ViewModel POCO classes that contain just the details you need.

The reason you don't want to populate Entity classes partially with just the details you need is because those instances no longer represent complete entities, they are partial shells of entities. Any method that expects to receive an entity could be passed one of these incomplete entities with things like default values and #nulls. Using a DTO definition avoids any confusion about what data would be coming through.

When querying across an entity graph you can flatten the details from related entities into fields or a different structure. While the SQL won't look that different at a glance, projection generally reduces the amount of data traveling over the wire and also allows you to tune indexing for high-usage scenarios which can significantly improve performance.

So for instance you could flatten the DTO to something like:

var ordenes = await _context.Ordenes
    .Select(o => new OrdenDto
    {
        Id = o.Id,
        Estatus = o.Estatus,
        FechaRegistro = o.FechaRegistro,
        FechaRequerida = o.FechaRequerida,
        Detalles = o.Detalles.Select(d => new OrdenDetallesDto
        {
            ColorNombre = d.Color.Nombre,
            TelaNombre = d.Tela.Nombre,
            Cantidad = d.Cantidad,
            ProductosAlmacenados = d.ProductosAlmacenados
        }).ToList()
    }).ToListAsync();

return ordenes;