Projection

Projection means asking the database for a specific shape rather than a whole entity. In LINQ that is Select.

A read path almost never needs every column. An order list screen shows a date, a customer name and a total; it does not show the shipping address, the internal notes or the audit fields. Projection is how you say so, and it is usually the right default for anything that only displays data.

// Loads every mapped column of Order, plus every column of Customer.
List<Order> entities = await context.Orders
    .Include(o => o.Customer)
    .Where(o => o.Status == OrderStatus.Open)
    .ToListAsync();

// The shape the screen actually needs.
public record OrderListItem(int Id, DateTime OrderDate, string CustomerName, decimal Total);

List<OrderListItem> rows = await context.Orders
    .Where(o => o.Status == OrderStatus.Open)
    .Select(o => new OrderListItem(
        o.Id,
        o.OrderDate,
        o.Customer.Name,
        o.Items.Sum(i => i.Quantity * i.UnitPrice)))
    .ToListAsync();

• The projection never mentions Include. Navigating to o.Customer.Name inside the Select is enough for EF Core to add the join it needs, and nothing more.
• o.Items.Sum(...) is translated into SQL and computed by the database. The order items never travel to your process at all.
• A record is convenient here because the type exists only to carry four values. An ordinary class works identically; so does an anonymous type if the result never leaves the method.
• Both queries filter on Status in the database. Projection changes what comes back, not what gets filtered.

-- From the entity query
SELECT [o].[Id], [o].[CustomerId], [o].[OrderDate], [o].[Status],
       [o].[ShippingAddress], [o].[Notes], [o].[PlacedByEmployeeId],
       [c].[Id], [c].[Name], [c].[Email], [c].[Phone], [c].[BillingAddress]
FROM [Orders] AS [o]
INNER JOIN [Customers] AS [c] ON [o].[CustomerId] = [c].[Id]
WHERE [o].[Status] = 1;

-- From the projection
SELECT [o].[Id], [o].[OrderDate], [c].[Name],
       COALESCE((
           SELECT SUM([i].[Quantity] * [i].[UnitPrice])
           FROM [OrderItems] AS [i]
           WHERE [o].[Id] = [i].[OrderId]), 0.0) AS [Total]
FROM [Orders] AS [o]
INNER JOIN [Customers] AS [c] ON [o].[CustomerId] = [c].[Id]
WHERE [o].[Status] = 1;

• Thirteen columns against three and a subquery. On a table where Notes holds a few kilobytes per row, that difference is most of the response time.
• The COALESCE is EF Core protecting the C# type: SUM over no rows is NULL in SQL, and Total is a non-nullable decimal.
• The total is now computed by the database. In the entity version you would fetch every order item and add them up in your process, which moves far more data to do the same arithmetic.