conditional where in linq query

Question

I want to return the total sum from a linq query, I pass in 2 parameters that may/may not be included in the query.

OrgId - int

reportType - int

So two questions:

1. How can I update the query below so that if OrgId = 0 then ignore the organisation field(Return All)?

2. LocumClaimTF can be True/False/Both, if both then ignore the where query for this field.

Heres what I have done so far, this is working but I'd like something for efficient.

            // Using reportType set preferences for LocumClaimTF
            bool locumClaimTF1, locumClaimTF2 = false;
            if (reportType == 0)
            {
                locumClaimTF1 = false;
                locumClaimTF2 = false;
            }
            else if (reportType == 1)
            {
                locumClaimTF1 = true;
                locumClaimTF2 = true;
            }
            else // 2
            {
                locumClaimTF1 = true;
                locumClaimTF2 = false;
            }

            if (OrgID != 0) // Get by OrgID
            {
                return _UoW.ShiftDates.Get(x => x.shiftStartDate >= StartDate && x.shiftEndDate <= EndDate)
             .Where(x => x.Shift.LocumClaimTF == locumClaimTF1 || x.Shift.LocumClaimTF == locumClaimTF2)
             .Where(x => x.Shift.organisationID == OrgID)
             .GroupBy(s => s.assignedLocumID)
                 .Select(g => new dataRowDTO { dataLabel = string.Concat(g.FirstOrDefault().User.FullName), dataCount = g.Count(), dataCurrencyAmount = g.Sum(sd => sd.shiftDateTotal.Value) }
                ).Sum(g=>g.dataCurrencyAmount);
            }
            else // Ignore OrgID - Get ALL Orgs
            {
                return _UoW.ShiftDates.Get(x => x.shiftStartDate >= StartDate && x.shiftEndDate <= EndDate)
               .Where(x => x.Shift.LocumClaimTF == locumClaimTF1 || x.Shift.LocumClaimTF == locumClaimTF2)
               .GroupBy(s => s.assignedLocumID)
                  .Select(g => new dataRowDTO { dataLabel = string.Concat(g.FirstOrDefault().User.FullName), dataCount = g.Count(), dataCurrencyAmount = g.Sum(sd => sd.shiftDateTotal.Value) }
                  ).Sum(g => g.dataCurrencyAmount);
            }

I'm using EF with unit of work pattern to get data frm

Answer 1

A few things come to mind, from top to bottom:

For handling the Booleans

bool locumClaimTF1 = (reportType == 1 || reportType == 2);
bool locumClaimTF2 = (reportType == 1);

From what I read in the query though, if the report type is 1 or 2, you want the Shift's LocumClaimTF flag to have to be True. If that is the case, then you can forget the Boolean flags and just use the reportType in your condition.

Next, for composing the query, you can conditionally compose where clauses. This is a nice thing about the fluent Linq syntax. However, let's start temporarily with a regular DbContext rather than the UoW because that will introduce some complexities and questions that you'll need to look over. (I will cover that below)

using (var context = new ApplicationDbContext()) // <- insert your DbContext here...
{
    var query = context.ShiftDates
       .Where(x => x.shiftStartDate >= StartDate 
           && x.shiftEndDate <= EndDate);
    if (reportType == 1 || reportType == 2)
       query = query.Where(x.Shift.LocumClaimTF);
    if (OrgId > 0)
       query = query.Where(x => x.Shift.organisationID == OrgID);

    var total = query.GroupBy(s => s.assignedLocumID)
        .Select(g => new dataRowDTO 
        { 
           dataLabel = tring.Concat(g.FirstOrDefault().User.FullName), 
           dataCount = g.Count(), 
           dataCurrencyAmount = g.Sum(sd => sd.shiftDateTotal.Value) 
        })
        .Sum(g=>g.dataCurrencyAmount);
}

Now this here didn't make any sense. Why are you going through the trouble of grouping, counting, and summing data, just to sum the resulting sums? I suspect you've copied an existing query that was selecting a DTO for the grouped results. If you don't need the grouped results, you just want the total. So in that case, do away with the grouping and just take the sum of all applicable records:

    var total = query.Sum(x => x.shiftDateTotal.Value);

So the whole thing would look something like:

using (var context = new ApplicationDbContext()) // <- insert your DbContext here...
{
    var query = context.ShiftDates
       .Where(x => x.shiftStartDate >= StartDate 
           && x.shiftEndDate <= EndDate);
    if (reportType == 1 || reportType == 2)
       query = query.Where(x.Shift.LocumClaimTF);
    if (OrgId > 0)
       query = query.Where(x => x.Shift.organisationID == OrgID);

    var total = query.Sum(x => x.shiftDateTotal.Value);
    return total;
}

Back to the Unit of Work: The main consideration when using this pattern is ensuring that this Get call absolutely must return back an IQueryable<TEntity>. If it returns anything else, such as IEnumerable<TEntity> then you are going to be facing significant performance problems as it will be returning materialized lists of entities loaded to memory rather than something that you can extend to build efficient queries to the database. If the Get method does not return IQueryable, or contains methods such as ToList anywhere within it followed by AsQueryable(), then have a talk with the rest of the dev team because you're literally standing on the code/EF equivalent of a land mine. If it does return IQueryable<TEntity> (IQueryable<ShiftDate> in this case) then you can substitute it back into the above query:

var query = _UoW.ShiftDates.Get(x => x.shiftStartDate >= StartDate && x.shiftEndDate <= EndDate);
if (reportType == 1 || reportType == 2)
   query = query.Where(x.Shift.LocumClaimTF);
if (OrgId > 0)
   query = query.Where(x => x.Shift.organisationID == OrgID);

var total = query.Sum(x => x.shiftDateTotal.Value);
return total;