实体框架共享查询

Question

I don't quite know how to word this, so I'm just going to explain my scenario.

I have a scenario where I have a TerminationDate field on an EmploymentHistory table that can be null, or a date in the future. EmploymentHistory joins to an Employees table and it's a 1:M relationship, where a single Employee can have multiple EmploymentHistory records. That Employees table joins to a lot of different places such as a Users table that represents the front end portal the Employees can log in to.

I frequently need to grab only the active employees. The SQL logic for being active is WHERE TerminationDate IS NULL OR TerminationDate >= GETDATE() . So if TerminationDate is null or if it's set in the future.

So in EF I have these queries like this:

// Grab all Active Employees context.Employees.Where(e => e.EmploymentHistory.Any(eh => eh.TerminationDate == null || eh.TerminationDate >= DateTime.Today).ToList();

// Get all Users context.Users.Where(u => u.Employee.EmploymentHistory.Any(eh => eh.TerminationDate == null || eh.TerminationDate >= DateTime.Today).ToList();

etc

This logic shows up in about 5 different places. How do I share the EmploymentHistory.Any(eh => eh.TerminationDate == null || eh.TerminationDate >= DateTime.Today part of the logic when the base nav prop may be different? Tried playing with Expression<Func<T, bool>> but got no where other than I think I have a solution if I can make all the Entities that need this inherit from a Base and could always assume there's a nav prop called Employee sitting there and the Base is my T . If I try an extension method, EF Core can only evaluate it client side, not server side.

Answer 1

You could write an expression for the EmploymentHistory : Expression<Func<EmploymentHistory, bool>> activeEmployee = eh => eh.TerminationDate == null || eh.TerminationDate >= DateTime.Today; Expression<Func<EmploymentHistory, bool>> activeEmployee = eh => eh.TerminationDate == null || eh.TerminationDate >= DateTime.Today;

And use it like so:
context.Employees.Where(e => e.EmploymentHistory.Any(activeEmployee)).ToList();
and
context.Users.Where(u => u.Employee.EmploymentHistory.Any(activeEmployee)).ToList(); .

It's not a huge reduction in code, but a lot less typing, and even better if you need to change the logic for some reason and don't want to change it everywhere is shows up.

Answer 2

There are a number of ways to do this. Using SQL Server and EF you could

1. Create a function in SQL and import it into EF. It's a little tricky, but it can be done.
2. Create a View on the server that does the computation and define the relationships in EF so that you can call from the view and greedy load the information that you need from there.
3. Add a computed column to the table to show whether the user is active or not.
4. Add a materialized column to the table to track whether or not the user is active and maintain that column in addition to the existing data.

I tried option one in an older version of EF and it took forever to work through it. The performance wasn't great and I never tried it again. It looks like this has gotten easier in newer versions of EF though, so you're welcome to give it a try.

Option 2 probably offers the best balance of performance and accuracy since you can optimize the query for the view and then still greedy load the data for best efficiency.

Option 3 works a lot like option 2 and makes for the simplest C# code, but it's not going to be quite as efficient since it will have to handle the columns individually rather than in aggregate.

There are times that I've found you have to use materialized information and it does offer the absolute best performance since there's no added calculation at runtime. You risk your data being out of sync though, so I would reserve it for only the most severe cases where that performance is critical.

Answer 3

The bug that @Rounder referenced in his comment on @WeskerTyrant 's answer here has now been resolved in EF Core.

So, you can do something like this:

Expression<Func<T, bool>> IsActiveEmployee =
    eh => eh.TerminationDate == null ||
          eh.TerminationDate >= DateTime.Today

And then call it like:

context.Users.AsQueryable().Where(IsActiveEmployee).ToList();

Notice the addition of the .AsQueryable() that allows the .Where() to accept an Expression .