LeftJoin and RightJoin Operators in EF Core 10

Outer joins play a major role in relational data access, yet writing them in LINQ has never been as intuitive as writing SQL. Developers were required to combine GroupJoin, SelectMany, and DefaultIfEmpty() to mimic SQL’s LEFT JOIN behavior. Although the output was correct, the LINQ expressions didn’t clearly communicate intent, especially for developers who came from a SQL-first background.

With the release of EF Core 10 in .NET 10, Microsoft finally introduced two native LINQ operators — LeftJoin and RightJoin — to simplify outer-join scenarios. These operators produce cleaner code, better readability, and SQL that matches exactly what the developer expects. This article explains how these new operators work, how they compare to older LINQ patterns, and how EF Core 10 generates SQL for both join types.

Before EF Core 10, developers had to rely on a combination of GroupJoin and DefaultIfEmpty() to simulate a left join. Although the approach functioned correctly, it often looked more complex than necessary. Consider the following example, which retrieves customers and their matching orders while including customers without orders.

var query =
    from customer in dbContext.Customers
    join order in dbContext.Orders
        on customer.Id equals order.CustomerId into orderGroup
    from order in orderGroup.DefaultIfEmpty()
    select new
    {
        customer.Name,
        order.Id,
        OrderAmount = order.Amount
    };

var query =
    from customer in dbContext.Customers
    join order in dbContext.Orders
        on customer.Id equals order.CustomerId into orderGroup
    from order in orderGroup.DefaultIfEmpty()
    select new
    {
        customer.Name,
        order.Id,
        OrderAmount = order.Amount
    };

Understanding this requires knowing why a GroupJoin is needed, how the “into orderGroup” clause behaves, and why DefaultIfEmpty() is responsible for enabling the “outer” part of the join. This often confused developers who expected LINQ to naturally support SQL-style joins.

SELECT 
    [c].[Name], 
    [o].[Id], 
    [o].[Amount] AS [OrderAmount]
FROM [Customers] AS [c]
LEFT JOIN [Orders] AS [o] ON [c].[Id] = [o].[CustomerId]

SELECT 
    [c].[Name], 
    [o].[Id], 
    [o].[Amount] AS [OrderAmount]
FROM [Customers] AS [c]
LEFT JOIN [Orders] AS [o] ON [c].[Id] = [o].[CustomerId]

Although the SQL was correct and efficient, the LINQ used to produce it was not immediately readable.

EF Core 10 introduces a LeftJoin operator that allows developers to express the same relationship using simpler, more intuitive LINQ. The developer clearly indicates the left side of the join, the key selectors, and the projection. No GroupJoin, no nested clauses, and no need for DefaultIfEmpty().

var query = dbContext.Customers
    .LeftJoin(
        dbContext.Orders,
        customer => customer.Id,
        order => order.CustomerId,
        (customer, order) => new
        {
            CustomerName = customer.Name,
            OrderAmount= (int?) order.Amount ?? 0,
        });

var query = dbContext.Customers
    .LeftJoin(
        dbContext.Orders,
        customer => customer.Id,
        order => order.CustomerId,
        (customer, order) => new
        {
            CustomerName = customer.Name,
            OrderAmount= (int?) order.Amount ?? 0,
        });

The name LeftJoin makes the intention obvious. Anyone reading the code can instantly understand what type of join is being performed. It also brings LINQ syntax closer to SQL, reducing mental friction when switching between C# code and database queries.

Right joins were even more cumbersome to express before EF Core 10. Developers often had to reverse sequences or resort to raw SQL. EF Core 10 addresses this by adding a dedicated RightJoin operator, allowing developers to start with the right-side entity as the primary focus of the query.

var query = dbContext.Orders
    .RightJoin(
        dbContext.Customers,
        order => order.CustomerId,
        customer => customer.Id,       
        (order, customer) => new
        {
            OrderId = order.Id,
            CustomerName = customer.Name ?? "NA"
        });

var query = dbContext.Orders
    .RightJoin(
        dbContext.Customers,
        order => order.CustomerId,
        customer => customer.Id,       
        (order, customer) => new
        {
            OrderId = order.Id,
            CustomerName = customer.Name ?? "NA"
        });

This is especially useful in reporting or auditing scenarios where the right-side entity must always appear—even if the related left-side entity is missing.

Although right joins are less common in modern application queries, having native support adds flexibility when dealing with legacy or inconsistent data.

The introduction of LeftJoin and RightJoin represents a meaningful improvement to LINQ’s expressiveness. These operators eliminate the need to remember complex join patterns and instead encourage developers to write queries that align more closely with SQL logic. This improves:

• readability
• onboarding for team members
• maintainability
• accuracy when modifying or reviewing queries

In large EF Core–based applications that rely on relational data, these improvements help developers avoid subtle mistakes and write more intention-revealing code.

EF Core 10 introduces LeftJoin and RightJoin operators that simplify outer joins in LINQ by replacing verbose patterns with concise, expressive syntax. Instead of relying on GroupJoin and DefaultIfEmpty(), developers can now write queries that clearly reflect SQL semantics. The new operators generate predictable SQL, making relational queries in .NET 10 easier to write, review, and maintain.

• LeftJoin in EF Core provides a clean, SQL-like way to perform left joins in LINQ.
• The old LINQ approach required multiple operators and was harder to read.
• RightJoin completes the outer-join story, allowing developers to anchor queries on the right side.
• EF Core 10 translates these new operators into efficient SQL joins.
• Code readability and maintainability significantly improve in .NET 10 applications using these operators.