Return to Question

protected async Task LoadRecursiveAsync<TEntityToLoad>(TEntityToLoad entity, CancellationToken cancellationToken) where TEntityToLoad : class, IEntity
{
    EntityEntry<TEntityToLoad> entry = this.Context.Entry(entity);

    foreach (NavigationEntry navigationEntry in entry.Navigations.Where(ne => !ne.IsLoaded))
    {
        cancellationToken.ThrowIfCancellationRequested();
        
        await LoadRecursiveAsyncInternal(navigationEntry);
    }

    return;

    async Task LoadRecursiveAsyncInternal(NavigationEntry navigationEntry)
    {
        await navigationEntry.LoadAsync(cancellationToken);

        object? currentValue = navigationEntry.CurrentValue;

        switch (currentValue)
        {
            case IEntity loadedEntity:
            {
                foreach (NavigationEntry navigation in this.Context.Entry(loadedEntity).Navigations.Where(ne => !ne.IsLoaded))
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    
                    await LoadRecursiveAsyncInternal(navigation);
                }

                break;
            }
            case null:
                break;
            default:
            {
                Type type = currentValue.GetType();
            
                if(!type.IsAssignableTo(typeof(IEnumerable)))
                {
                    return;
                }

                if (type.GetGenericArguments() is [{ } entityType] && entityType.IsAssignableTo(typeof(IEntity)))
                {
                    foreach (IEntity loadedEntity in (IEnumerable)currentValue)
                    {
                        foreach (NavigationEntry navigation in this.Context.Entry(loadedEntity).Navigations.Where(ne => !ne.IsLoaded))
                        {
                            cancellationToken.ThrowIfCancellationRequested();
                            
                            await LoadRecursiveAsyncInternal(navigation);
                        }
                    }
                }

                break;
            }
        }
    }
}

protected async Task LoadRecursiveAsync<TEntityToLoad>(TEntityToLoad entity, CancellationToken cancellationToken) where TEntityToLoad : class, IEntity
{
    // this.Context is of type Microsoft.EntityFrameworkCore.DbContext
    EntityEntry<TEntityToLoad> entry = this.Context.Entry(entity);

    foreach (NavigationEntry navigationEntry in entry.Navigations.Where(ne => !ne.IsLoaded))
    {
        cancellationToken.ThrowIfCancellationRequested();
        
        await LoadRecursiveAsyncInternal(navigationEntry);
    }

    return;

    async Task LoadRecursiveAsyncInternal(NavigationEntry navigationEntry)
    {
        await navigationEntry.LoadAsync(cancellationToken);

        object? currentValue = navigationEntry.CurrentValue;

        switch (currentValue)
        {
            case IEntity loadedEntity:
            {
                foreach (NavigationEntry navigation in this.Context.Entry(loadedEntity).Navigations.Where(ne => !ne.IsLoaded))
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    
                    await LoadRecursiveAsyncInternal(navigation);
                }

                break;
            }
            case null:
                break;
            default:
            {
                Type type = currentValue.GetType();
            
                if(!type.IsAssignableTo(typeof(IEnumerable)))
                {
                    return;
                }

                if (type.GetGenericArguments() is [{ } entityType] && entityType.IsAssignableTo(typeof(IEntity)))
                {
                    foreach (IEntity loadedEntity in (IEnumerable)currentValue)
                    {
                        foreach (NavigationEntry navigation in this.Context.Entry(loadedEntity).Navigations.Where(ne => !ne.IsLoaded))
                        {
                            cancellationToken.ThrowIfCancellationRequested();
                            
                            await LoadRecursiveAsyncInternal(navigation);
                        }
                    }
                }

                break;
            }
        }
    }
}

Edit 2: Comparison of manual includes with the above recursive method, made with BenchmarkDotNet (Runtime: .NET 6.0, IterationCount 100)

protected async Task LoadRecursiveAsync<TEntityToLoad>(TEntityToLoad entity) where TEntityToLoad : class, IEntity
    {
        // this.Context is of type Microsoft.EntityFrameworkCore.DbContext
        EntityEntry<TEntityToLoad> entry = this.Context.Entry(entity);

        foreach (NavigationEntry navigationEntry in entry.Navigations.Where(ne => !ne.IsLoaded))
        {
            await LoadRecursiveAsyncInternal(navigationEntry);
        }

        return;

        async Task LoadRecursiveAsyncInternal(NavigationEntry navigationEntry)
        {
            await navigationEntry.LoadAsync();

            object? currentValue = navigationEntry.CurrentValue;

            switch (currentValue)
            {
                case IEntity loadedEntity:
                {
                    foreach (NavigationEntry navigation in this.Context.Entry(loadedEntity).Navigations.Where(ne => !ne.IsLoaded))
                    {
                        await LoadRecursiveAsyncInternal(navigation);
                    }

                    break;
                }
                case null:
                    break;
                default:
                {
                    Type type = currentValue.GetType();
                
                    if(!type.IsAssignableTo(typeof(IEnumerable)))
                    {
                        return;
                    }

                    if (type.GetGenericArguments() is [{ } entityType] && entityType.IsAssignableTo(typeof(IEntity)))
                    {
                        foreach (IEntity loadedEntity in (IEnumerable)currentValue)
                        {
                            foreach (NavigationEntry navigation in this.Context.Entry(loadedEntity).Navigations.Where(ne => !ne.IsLoaded))
                            {
                                await LoadRecursiveAsyncInternal(navigation);
                            }
                        }
                    }
 
                    break;
                }
            }
        }
    }

protected async Task LoadRecursiveAsync<TEntityToLoad>(TEntityToLoad entity, CancellationToken cancellationToken) where TEntityToLoad : class, IEntity
{
    EntityEntry<TEntityToLoad> entry = this.Context.Entry(entity);

    foreach (NavigationEntry navigationEntry in entry.Navigations.Where(ne => !ne.IsLoaded))
    {
        cancellationToken.ThrowIfCancellationRequested();
        
        await LoadRecursiveAsyncInternal(navigationEntry);
    }

    return;

    async Task LoadRecursiveAsyncInternal(NavigationEntry navigationEntry)
    {
        await navigationEntry.LoadAsync(cancellationToken);

        object? currentValue = navigationEntry.CurrentValue;

        switch (currentValue)
        {
            case IEntity loadedEntity:
            {
                foreach (NavigationEntry navigation in this.Context.Entry(loadedEntity).Navigations.Where(ne => !ne.IsLoaded))
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    
                    await LoadRecursiveAsyncInternal(navigation);
                }
 
                break;
            }
            case null:
                break;
            default:
            {
                Type type = currentValue.GetType();
            
                if(!type.IsAssignableTo(typeof(IEnumerable)))
                {
                    return;
                }

                if (type.GetGenericArguments() is [{ } entityType] && entityType.IsAssignableTo(typeof(IEntity)))
                {
                    foreach (IEntity loadedEntity in (IEnumerable)currentValue)
                    {
                        foreach (NavigationEntry navigation in this.Context.Entry(loadedEntity).Navigations.Where(ne => !ne.IsLoaded))
                        {
                            cancellationToken.ThrowIfCancellationRequested();
                             
                            await LoadRecursiveAsyncInternal(navigation);
                        }
                    }
                }

                break;
            }
        }
    }
}