Is projecting directly to nested DTOs using ternary operators to handle nulls a reliable pattern in EF Core 8?

I am using .NET 8 and Entity Framework Core 8.

I am building a query layer where my methods return IQueryable to allow for further composition (filtering, sorting, paging) before execution.

My DTOs often have nested objects that represent related entities. For example, an OrderDto might contain a CustomerDto object. A common challenge is handling nullable relationships (e.g., an Order might not have a Customer assigned yet).

To handle this, I'm using a ternary operator ( ... != null ? new Dto { ... } : null) directly inside my .Select() projection. This seems to work, but I'm concerned about whether this is a robust and recommended best practice, or if it might lead to translation issues or performance problems in more complex scenarios.

My question is: Is projecting directly to nested DTOs using ternary operators to handle nulls a reliable pattern in EF Core 8? Or is there a more standard or safer way to achieve this?

Here is a simplified, generic example that demonstrates my approach. Let's assume we have ParentEntity and ChildEntity models. I want to query a list of ParentEntity and project them into ParentDto, which contains a nested ChildDto.

The Entities

public class ParentEntity {    public int Id { get; set; }    public string Name { get; set; }    public int? ChildId { get; set; } // Nullable foreign key    public ChildEntity Child { get; set; } // Nullable navigation property}

public class ChildEntity{    public int Id { get; set; }    public string Description { get; set; }}

The Dto's

public class ParentDto{    public int Id { get; set; }    public string Name { get; set; }    public ChildDto? Child { get; set; } // Nested DTO}public class ChildDto{    public int Id { get; set; }    public string Description { get; set; }}

The Query Method

public IQueryable<ParentDto> GetParentDtos(DbContext dbContext){    return dbContext.Parents        .AsNoTracking()        .Select(parent => new ParentDto        {            Id = parent.Id,            Name = parent.Name,            // This is the pattern in question:            // Is this ternary operator reliable for EF Core's SQL translation?            Child = (parent.Child != null) ? new ChildDto            {                Id = parent.Child.Id,                Description = parent.Child.Description            } : null        });}

Generated T-SQL Query using ternary operator

SELECT [p].[Id], [p].[Name], CASE          WHEN [c].[Id] IS NOT NULL THEN CAST(1 AS bit)          ELSE CAST(0 AS bit)      END, [c].[Id], [c].[Description]      FROM [parents] AS [p]      LEFT JOIN [children] AS [c] ON [p].[ChildId] = [c].[Id]

T-SQL Query NOT using ternary operator

SELECT [p].[Id], [p].[Name], [c].[Id], [c].[Description]      FROM [parents] AS [p]      LEFT JOIN [children] AS [c] ON [p].[ChildId] = [c].[Id]