Looking to combine two methods with c#

Question

HI all i have below two methods and looking to combine both and one method does not need any joins and other method need those how can i combine these two methods

    internal static IQueryable<ConstructionSet> CalculateSelectedConstructionSetsForOSM(Guid? ashraeClimateZoneId,
                                                                                        Guid? energyCodeId,
                                                                                        Guid? massingTypeId,
                                                                                        APIDbContext dbContext)
    {
        if (dbContext is null)
        {
            throw new ArgumentNullException(nameof(dbContext));
        }

        return dbContext.ConstructionSets.Include(p => p.AshraeClimateZone)
                                         .Include(p => p.MassingType)
                                         .Include(p => p.SourceOfData)
                                         .Include(p => p.ExteriorWall)
                                         .Include(p => p.ExteriorFloor)
                                         .Include(p => p.InteriorFloor)
                                         .Include(p => p.InteriorWall)
                                         .Include(p => p.SlabOnGrade)
                                         .Include(p => p.BelowGradeWall)
                                         .Include(p => p.Glazing)
                                         .Include(p => p.Roof)
                                         .Where(p => p.AshraeClimateZoneId == ashraeClimateZoneId
                                         && p.SourceOfDataId == energyCodeId
                                         && p.MassingTypeId == massingTypeId
                                         && p.Revision != null
                                         && p.IsApproved == true)
                                         .AsEnumerable()
                                         .OrderByDescending(i => i.Revision)
                                         .GroupBy(i => i.InitialRevisionId)
                                         .Select(g => g.First()).AsQueryable();
    }

the below one is another method

    internal static IQueryable<ConstructionSet> CalculateSelectedConstructionSetsForProject(Guid? ashraeClimateZoneId,
                                                                                            Guid? energyCodeId,
                                                                                            Guid? massingTypeId,
                                                                                            APIDbContext dbContext)
    {
        if (dbContext is null)
        {
            throw new ArgumentNullException(nameof(dbContext));
        }

        return dbContext.ConstructionSets.Include(p => p.AshraeClimateZone)
                                         .Include(p => p.MassingType)
                                         .Include(p => p.SourceOfData)
                                         .Where(p => p.AshraeClimateZoneId == ashraeClimateZoneId
                                         && p.SourceOfDataId == energyCodeId
                                         && p.MassingTypeId == massingTypeId
                                         && p.Revision != null
                                         && p.IsApproved == true)
                                         .AsEnumerable()
                                         .OrderByDescending(i => i.Revision)
                                         .GroupBy(i => i.InitialRevisionId)
                                         .Select(g => g.First()).AsQueryable();
    }

Could any one please let me know how can i combine these methods, many thanks in advance.

Answer 1

Assuming by "combine them" you mean "refactor them so a single method can handle both cases", you can do something like this:

internal static IQueryable<ConstructionSet> CalculateSelectedConstructionSets(Guid? ashraeClimateZoneId,
                                                                                    Guid? energyCodeId,
                                                                                    Guid? massingTypeId,
                                                                                    APIDbContext dbContext,
                                                                                    bool includeOsmNavigationProperties)
{
    if (dbContext is null)
    {
        throw new ArgumentNullException(nameof(dbContext));
    }

    var sets = dbContext.ConstructionSets.Include(p => p.AshraeClimateZone)
                                     .Include(p => p.MassingType)
                                     .Include(p => p.SourceOfData);
    if(includeOsmNavigationProperties)
    {
        sets = sets.Include(p => p.ExteriorWall)
                                     .Include(p => p.ExteriorFloor)
                                     .Include(p => p.InteriorFloor)
                                     .Include(p => p.InteriorWall)
                                     .Include(p => p.SlabOnGrade)
                                     .Include(p => p.BelowGradeWall)
                                     .Include(p => p.Glazing)
                                     .Include(p => p.Roof);
    }
    return sets.Where(p => p.AshraeClimateZoneId == ashraeClimateZoneId
                                     && p.SourceOfDataId == energyCodeId
                                     && p.MassingTypeId == massingTypeId
                                     && p.Revision != null
                                     && p.IsApproved == true)
                                     .AsEnumerable()
                                     .OrderByDescending(i => i.Revision)
                                     .GroupBy(i => i.InitialRevisionId)
                                     .Select(g => g.First()).AsQueryable();
}

As a side note, you should avoid the pattern of converting this to .AsEnumerable() and then back to .AsQueryable(). Making the result an IQueryable makes subsequent operations on the returned collection much slower (expressions need to be compiled at run-time), and it hides the fact that you won't be performing subsequent operations at the database layer. Someone might add a Where() clause and not realize that they're still causing the entire set of data to get loaded out of the database.